int main(int, char**) (int argc, char * * argv)
{
  bool retval.0;
  bool D.93355;
  int D.93358;
  int iftmp.1;
  bool D.93360;
  struct lambda D.41350;
  int D.93364;
  struct basic_ostream & D.93365;
  const struct string D.41421;
  struct allocator D.41420;
  struct lambda D.42549;
  const int D.41431;
  int D.93366;
  struct basic_ostream & D.93367;
  const struct string D.42616;
  struct allocator D.42615;
  struct lambda D.43433;
  const int D.42622;
  int D.93368;
  struct basic_ostream & D.93369;
  const struct string D.43478;
  struct allocator D.43477;
  struct lambda D.44299;
  const int D.43484;
  int D.93370;
  struct basic_ostream & D.93371;
  const struct string D.44348;
  struct allocator D.44347;
  struct lambda D.45165;
  const int D.44354;
  int D.93372;
  struct basic_ostream & D.93373;
  const struct string D.45210;
  struct allocator D.45209;
  struct lambda D.47313;
  struct lambda D.46481;
  int D.93374;
  struct basic_ostream & D.93375;
  const struct string D.47395;
  struct allocator D.47394;
  struct lambda D.49031;
  const int D.48216;
  struct lambda D.48208;
  int D.93376;
  struct basic_ostream & D.93377;
  const struct string D.49124;
  struct allocator D.49123;
  int a.2;
  struct lambda D.49127;
  const int D.49126;
  struct lambda D.49125;
  int D.93379;
  struct basic_ostream & D.93380;
  struct basic_ostream & D.93381;
  const struct string D.49130;
  struct allocator D.49129;
  struct lambda D.51575;
  const int D.50764;
  struct lambda D.50758;
  struct lambda D.49947;
  int D.93382;
  struct basic_ostream & D.93383;
  struct basic_ostream & D.93384;
  const struct string D.51701;
  struct allocator D.51700;
  struct lambda D.52514;
  int D.93385;
  struct basic_ostream & D.93386;
  const struct string D.52561;
  struct allocator D.52560;
  struct lambda D.54175;
  const int D.52891;
  struct lambda D.52881;
  int * const D.52568;
  int & D.93387;
  int D.93388;
  struct basic_ostream & D.93389;
  const struct string D.54178;
  struct allocator D.54177;
  struct lambda D.55440;
  int & D.93390;
  int D.93391;
  struct basic_ostream & D.93392;
  const struct string D.55515;
  struct allocator D.55514;
  struct lambda D.56786;
  struct lambda D.55516;
  int D.93393;
  struct basic_ostream & D.93394;
  const struct string D.56872;
  struct allocator D.56871;
  struct lambda D.60948;
  struct lambda D.60121;
  struct lambda D.59296;
  struct lambda D.58474;
  struct lambda D.58473;
  struct lambda D.57184;
  struct lambda D.57183;
  int D.93395;
  struct basic_ostream & D.93396;
  int c.3;
  int b.4;
  struct basic_ostream & D.93399;
  struct basic_ostream & D.93400;
  struct basic_ostream & D.93401;
  struct basic_ostream & D.93402;
  struct basic_ostream & D.93403;
  const struct string D.61071;
  struct allocator D.61070;
  struct lambda D.63395;
  struct string D.62244;
  struct allocator D.62243;
  struct lambda D.62241;
  struct reference_wrapper D.61092;
  const struct string D.63615;
  struct allocator D.63614;
  struct lambda D.66081;
  struct string D.65262;
  struct allocator D.65261;
  struct lambda D.65259;
  struct lambda D.64431;
  struct reference_wrapper D.63616;
  const struct string D.66279;
  struct allocator D.66278;
  struct lambda D.68273;
  struct lambda D.67420;
  struct lambda D.67105;
  const int D.66291;
  struct lambda D.66285;
  const struct string D.68276;
  struct allocator D.68275;
  struct lambda D.68299;
  struct string D.68298;
  struct allocator D.68297;
  struct lambda D.68295;
  struct lambda D.68277;
  const struct string D.68302;
  struct allocator D.68301;
  const struct string D.68432;
  struct allocator D.68431;
  const struct slot D.70762;
  struct retype_return_functor D.70749;
  struct lambda D.70453;
  struct lambda D.69620;
  struct lambda D.69619;
  struct reference_wrapper D.68470;
  struct lambda D.68449;
  const struct string D.70766;
  struct allocator D.70765;
  const struct string D.70769;
  struct allocator D.70768;
  struct lambda D.72576;
  int (*<Tdd0e>) (int, int) D.70777;
  int D.93404;
  const struct string D.72690;
  struct allocator D.72689;
  struct lambda D.73516;
  int (*<Tdd0e>) (int, int) D.72697;
  int D.93405;
  const struct string D.73559;
  struct allocator D.73558;
  struct reference_wrapper D.93406;
  struct lambda D.75328;
  struct mem_functor2 D.73596;
  struct 
{
  int bar::<T729a> (struct bar *, int, int) * __pfn;
  long int __delta;
} D.93407;
  int D.93408;
  const struct string D.75504;
  struct allocator D.75503;
  struct lambda D.76329;
  int (*<Tdd0e>) (int, int) D.75511;
  int D.93409;
  const struct string D.76411;
  struct allocator D.76410;
  struct lambda D.77235;
  int (*<Tdd0e>) (int, int) D.76418;
  int D.93410;
  const struct string D.77238;
  struct allocator D.77237;
  struct lambda D.78518;
  struct pointer_functor1 D.77265;
  const struct string D.78521;
  struct allocator D.78520;
  const struct string D.78526;
  struct allocator D.78525;
  const struct slot D.79862;
  struct lambda D.79852;
  struct reference_wrapper D.93411;
  void (*<Tf7e8>) (struct basic_string &) D.78533;
  const struct string D.79865;
  struct allocator D.79864;
  struct string & D.93412;
  const struct string D.79868;
  struct allocator D.79867;
  const struct string D.79871;
  struct allocator D.79870;
  struct lambda D.79875;
  int (*<Tdd0e>) (int, int) D.79872;
  int D.93413;
  const struct string D.79955;
  struct allocator D.79954;
  struct lambda D.80773;
  struct pointer_functor1 D.79956;
  const struct string D.80838;
  struct allocator D.80837;
  struct lambda D.82127;
  int (*<Tdd0e>) (int, int) D.80839;
  struct lambda D.93414;
  int (*<Tdd0e>) (int, int) D.80853;
  int D.93415;
  const struct string D.82229;
  struct allocator D.82228;
  struct lambda D.83514;
  struct lambda D.93416;
  int (*<Tdd0e>) (int, int) D.82241;
  int D.93417;
  const struct string D.83614;
  struct allocator D.83613;
  int iftmp.5;
  bool D.93419;

  {
    struct TestUtilities * util;
    int a;
    int b;
    int c;
    struct slot sl1;
    struct bar the_bar;
    struct slot sl2;

    try
      {
        util = TestUtilities::get_instance ();
        D.93355 = TestUtilities::check_command_args (util, argc, argv);
        retval.0 = ~D.93355;
        if (retval.0 != 0) goto <D.93356>; else goto <D.93357>;
        <D.93356>:
        D.93360 = TestUtilities::get_result_and_delete_instance ();
        if (D.93360 != 0) goto <D.93361>; else goto <D.93362>;
        <D.93361>:
        iftmp.1 = 0;
        goto <D.93363>;
        <D.93362>:
        iftmp.1 = 1;
        <D.93363>:
        D.93358 = iftmp.1;
        return D.93358;
        <D.93357>:
        a = 1;
        sigc::operator+<sigc::internal::lambda_select1, sigc::internal::lambda_select2> (&_1, &_2);
        try
          {
            D.93364 = sigc::internal::lambda_core<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, sigc::internal::lambda_select2>, true>::operator()<int, int> (&D.41350.D.41348, 3, 4);
            D.93365 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "(_1 + _2) (3,4):    ");
            std::basic_ostream<char>::operator<< (D.93365, D.93364);
          }
        finally
          {
            D.41350 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.41420);
        try
          {
            std::basic_string<char>::basic_string (&D.41421, "(_1 + _2) (3,4):    7", &D.41420);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.41421);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.41421);
                D.41421 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.41420);
            D.41420 = {CLOBBER};
          }
        D.41431 = 1;
        try
          {
            D.42549 = sigc::operator+<sigc::internal::lambda_select1, int> (&_1, &D.41431);
            try
              {
                D.93366 = sigc::internal::lambda_core<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, int>, true>::operator()<int, int> (&D.42549.D.42547, 3, 4);
                D.93367 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "(_1 + 1)  (3,4):    ");
                std::basic_ostream<char>::operator<< (D.93367, D.93366);
              }
            finally
              {
                D.42549 = {CLOBBER};
              }
          }
        finally
          {
            D.41431 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.42615);
        try
          {
            std::basic_string<char>::basic_string (&D.42616, "(_1 + 1)  (3,4):    4", &D.42615);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.42616);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.42616);
                D.42616 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.42615);
            D.42615 = {CLOBBER};
          }
        D.42622 = 1;
        try
          {
            D.43433 = sigc::operator+<sigc::internal::lambda_select2, int> (&_2, &D.42622);
            try
              {
                D.93368 = sigc::internal::lambda_core<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select2, int>, true>::operator()<int, int> (&D.43433.D.43431, 3, 4);
                D.93369 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "(_2 + 1)  (3,4):    ");
                std::basic_ostream<char>::operator<< (D.93369, D.93368);
              }
            finally
              {
                D.43433 = {CLOBBER};
              }
          }
        finally
          {
            D.42622 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.43477);
        try
          {
            std::basic_string<char>::basic_string (&D.43478, "(_2 + 1)  (3,4):    5", &D.43477);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.43478);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.43478);
                D.43478 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.43477);
            D.43477 = {CLOBBER};
          }
        D.43484 = 2;
        try
          {
            D.44299 = sigc::operator+<int, sigc::internal::lambda_select1> (&D.43484, &_1);
            try
              {
                D.93370 = sigc::internal::lambda_core<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, int, sigc::internal::lambda_select1>, true>::operator()<int, int> (&D.44299.D.44297, 3, 4);
                D.93371 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "(2 + _1)  (3,4):    ");
                std::basic_ostream<char>::operator<< (D.93371, D.93370);
              }
            finally
              {
                D.44299 = {CLOBBER};
              }
          }
        finally
          {
            D.43484 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.44347);
        try
          {
            std::basic_string<char>::basic_string (&D.44348, "(2 + _1)  (3,4):    5", &D.44347);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.44348);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.44348);
                D.44348 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.44347);
            D.44347 = {CLOBBER};
          }
        D.44354 = 2;
        try
          {
            D.45165 = sigc::operator+<int, sigc::internal::lambda_select2> (&D.44354, &_2);
            try
              {
                D.93372 = sigc::internal::lambda_core<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, int, sigc::internal::lambda_select2>, true>::operator()<int, int> (&D.45165.D.45163, 3, 4);
                D.93373 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "(2 + _2)  (3,4):    ");
                std::basic_ostream<char>::operator<< (D.93373, D.93372);
              }
            finally
              {
                D.45165 = {CLOBBER};
              }
          }
        finally
          {
            D.44354 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.45209);
        try
          {
            std::basic_string<char>::basic_string (&D.45210, "(2 + _2)  (3,4):    6", &D.45209);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.45210);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.45210);
                D.45210 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.45209);
            D.45209 = {CLOBBER};
          }
        sigc::operator*<sigc::internal::lambda_select2, sigc::internal::lambda_select3> (&_2, &_3);
        try
          {
            sigc::operator+<sigc::internal::lambda_select1, sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::internal::lambda_select2, sigc::internal::lambda_select3> > (&_1, &D.46481);
            try
              {
                D.93374 = sigc::internal::lambda_core<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::internal::lambda_select2, sigc::internal::lambda_select3> >, true>::operator()<int, int, int> (&D.47313.D.47311, 1, 2, 3);
                D.93375 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "(_1+_2*_3)(1,2,3):  ");
                std::basic_ostream<char>::operator<< (D.93375, D.93374);
              }
            finally
              {
                D.47313 = {CLOBBER};
              }
          }
        finally
          {
            D.46481 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.47394);
        try
          {
            std::basic_string<char>::basic_string (&D.47395, "(_1+_2*_3)(1,2,3):  7", &D.47394);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.47395);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.47395);
                D.47395 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.47394);
            D.47394 = {CLOBBER};
          }
        D.48216 = 2;
        try
          {
            sigc::operator++<sigc::internal::lambda_select1> (&_1);
            try
              {
                D.49031 = sigc::operator*<sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::internal::lambda_select1>, int> (&D.48208, &D.48216);
                try
                  {
                    D.93376 = sigc::internal::lambda_core<sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::internal::lambda_select1>, int>, true>::operator()<int> (&D.49031.D.49029, 1);
                    D.93377 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "((++_1)*2)(1):      ");
                    std::basic_ostream<char>::operator<< (D.93377, D.93376);
                  }
                finally
                  {
                    D.49031 = {CLOBBER};
                  }
              }
            finally
              {
                D.48208 = {CLOBBER};
              }
          }
        finally
          {
            D.48216 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.49123);
        try
          {
            std::basic_string<char>::basic_string (&D.49124, "((++_1)*2)(1):      4", &D.49123);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.49124);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.49124);
                D.49124 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.49123);
            D.49123 = {CLOBBER};
          }
        a.2 = a;
        D.49126 = 2;
        try
          {
            sigc::operator++<sigc::internal::lambda_select1> (&_1);
            try
              {
                D.49127 = sigc::operator*<sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::internal::lambda_select1>, int> (&D.49125, &D.49126);
                try
                  {
                    D.93379 = sigc::internal::lambda_core<sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::internal::lambda_select1>, int>, true>::operator()<int> (&D.49127.D.49029, a.2);
                    D.93380 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "((++_1)*2)(a):      ");
                    std::basic_ostream<char>::operator<< (D.93380, D.93379);
                  }
                finally
                  {
                    D.49127 = {CLOBBER};
                  }
              }
            finally
              {
                D.49125 = {CLOBBER};
              }
          }
        finally
          {
            D.49126 = {CLOBBER};
          }
        a.2 = a;
        D.93381 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "; a: ");
        std::basic_ostream<char>::operator<< (D.93381, a.2);
        std::allocator<char>::allocator (&D.49129);
        try
          {
            std::basic_string<char>::basic_string (&D.49130, "((++_1)*2)(a):      4; a: 1", &D.49129);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.49130);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.49130);
                D.49130 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.49129);
            D.49129 = {CLOBBER};
          }
        D.50764 = 2;
        try
          {
            sigc::operator*<sigc::internal::lambda_select1> (&_1);
            try
              {
                sigc::operator++<sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> > (&D.49947);
                try
                  {
                    D.51575 = sigc::operator*<sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >, int> (&D.50758, &D.50764);
                    try
                      {
                        D.93382 = sigc::internal::lambda_core<sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >, int>, true>::operator()<int*> (&D.51575.D.51573, &a);
                        D.93383 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "((++(*_1))*2)(&a):  ");
                        std::basic_ostream<char>::operator<< (D.93383, D.93382);
                      }
                    finally
                      {
                        D.51575 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.50758 = {CLOBBER};
                  }
              }
            finally
              {
                D.49947 = {CLOBBER};
              }
          }
        finally
          {
            D.50764 = {CLOBBER};
          }
        a.2 = a;
        D.93384 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "; a: ");
        std::basic_ostream<char>::operator<< (D.93384, a.2);
        std::allocator<char>::allocator (&D.51700);
        try
          {
            std::basic_string<char>::basic_string (&D.51701, "((++(*_1))*2)(&a):  4; a: 2", &D.51700);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.51701);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.51701);
                D.51701 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.51700);
            D.51700 = {CLOBBER};
          }
        sigc::operator-<sigc::internal::lambda_select1> (&_1);
        try
          {
            D.93385 = sigc::internal::lambda_core<sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::negate>, sigc::internal::lambda_select1>, true>::operator()<int> (&D.52514.D.52512, -5);
            D.93386 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "(-_1)     (-5):     ");
            std::basic_ostream<char>::operator<< (D.93386, D.93385);
          }
        finally
          {
            D.52514 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.52560);
        try
          {
            std::basic_string<char>::basic_string (&D.52561, "(-_1)     (-5):     5", &D.52560);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.52561);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.52561);
                D.52561 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.52560);
            D.52560 = {CLOBBER};
          }
        D.52891 = 0;
        try
          {
            D.52568 = &a;
            try
              {
                D.52881 = sigc::var<int*> (&D.52568);
                try
                  {
                    D.54175 = sigc::lambda<int* const&>::operator[]<int> (&D.52881, &D.52891); [return slot optimization]
                    try
                      {
                        D.93387 = sigc::internal::lambda_core<sigc::lambda_operator<sigc::other<sigc::subscript>, sigc::lambda<int* const&>, int>, true>::operator() (&D.54175.D.54173);
                        D.93388 = *D.93387;
                        D.93389 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "(var(&a)[0])():     ");
                        std::basic_ostream<char>::operator<< (D.93389, D.93388);
                      }
                    finally
                      {
                        D.54175 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.52881 = {CLOBBER};
                  }
              }
            finally
              {
                D.52568 = {CLOBBER};
              }
          }
        finally
          {
            D.52891 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.54177);
        try
          {
            std::basic_string<char>::basic_string (&D.54178, "(var(&a)[0])():     2", &D.54177);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.54178);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.54178);
                D.54178 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.54177);
            D.54177 = {CLOBBER};
          }
        sigc::lambda<sigc::internal::lambda_select1>::operator[]<sigc::lambda<sigc::internal::lambda_select2> > (&_1, &_2);
        try
          {
            D.93390 = sigc::internal::lambda_core<sigc::lambda_operator<sigc::other<sigc::subscript>, sigc::lambda<sigc::internal::lambda_select1>, sigc::internal::lambda_select2>, true>::operator()<int*, int> (&D.55440.D.55438, &a, 0);
            D.93391 = *D.93390;
            D.93392 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "(_1[_2])    (&a,0): ");
            std::basic_ostream<char>::operator<< (D.93392, D.93391);
          }
        finally
          {
            D.55440 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.55514);
        try
          {
            std::basic_string<char>::basic_string (&D.55515, "(_1[_2])    (&a,0): 2", &D.55514);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.55515);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.55515);
                D.55515 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.55514);
            D.55514 = {CLOBBER};
          }
        sigc::operator*<sigc::internal::lambda_select1> (&_1);
        try
          {
            sigc::lambda<sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >::operator=<sigc::lambda<sigc::internal::lambda_select2> > (&D.55516, &_2);
            try
              {
                D.93393 = sigc::internal::lambda_core<sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >, sigc::internal::lambda_select2>, true>::operator()<int*, int> (&D.56786.D.56784, &a, 1);
                D.93394 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "(*_1=_2)    (&a,1): ");
                std::basic_ostream<char>::operator<< (D.93394, D.93393);
              }
            finally
              {
                D.56786 = {CLOBBER};
              }
          }
        finally
          {
            D.55516 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.56871);
        try
          {
            std::basic_string<char>::basic_string (&D.56872, "(*_1=_2)    (&a,1): 1", &D.56871);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.56872);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.56872);
                D.56872 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.56871);
            D.56871 = {CLOBBER};
          }
        a = -1;
        b = -1;
        c = -1;
        D.58474 = sigc::var<int> (&b);
        try
          {
            D.59296 = sigc::lambda<int&>::operator=<sigc::lambda<sigc::internal::lambda_select2> > (&D.58474, &_2); [return slot optimization]
            try
              {
                D.57184 = sigc::var<int> (&a);
                try
                  {
                    D.58473 = sigc::lambda<int&>::operator=<sigc::lambda<sigc::internal::lambda_select1> > (&D.57184, &_1); [return slot optimization]
                    try
                      {
                        D.60121 = sigc::operator,<sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> > (&D.58473, &D.59296); [return slot optimization]
                        try
                          {
                            D.57183 = sigc::var<int> (&c);
                            try
                              {
                                D.60948 = sigc::lambda<int&>::operator=<sigc::lambda<sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> > > > (&D.57183, &D.60121); [return slot optimization]
                                try
                                  {
                                    D.93395 = sigc::internal::lambda_core<sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> > >, true>::operator()<int, int> (&D.60948.D.60946, 2, 3);
                                    D.93396 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "(var(c) = (var(a) = _1, var(b) = _2))(2,3): ");
                                    std::basic_ostream<char>::operator<< (D.93396, D.93395);
                                  }
                                finally
                                  {
                                    D.60948 = {CLOBBER};
                                  }
                              }
                            finally
                              {
                                D.57183 = {CLOBBER};
                              }
                          }
                        finally
                          {
                            D.60121 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.58473 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.57184 = {CLOBBER};
                  }
              }
            finally
              {
                D.59296 = {CLOBBER};
              }
          }
        finally
          {
            D.58474 = {CLOBBER};
          }
        c.3 = c;
        b.4 = b;
        a.2 = a;
        D.93399 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "; a: ");
        D.93400 = std::basic_ostream<char>::operator<< (D.93399, a.2);
        D.93401 = std::operator<< <std::char_traits<char> > (D.93400, "; b: ");
        D.93402 = std::basic_ostream<char>::operator<< (D.93401, b.4);
        D.93403 = std::operator<< <std::char_traits<char> > (D.93402, "; c: ");
        std::basic_ostream<char>::operator<< (D.93403, c.3);
        std::allocator<char>::allocator (&D.61070);
        try
          {
            std::basic_string<char>::basic_string (&D.61071, "(var(c) = (var(a) = _1, var(b) = _2))(2,3): 3; a: 2; b: 3; c: 3", &D.61070);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.61071);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.61071);
                D.61071 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.61070);
            D.61070 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.62243);
        try
          {
            std::basic_string<char>::basic_string (&D.62244, "\n", &D.62243);
            try
              {
                D.61092 = sigc::ref<std::basic_ostringstream<char> > (&result_stream);
                try
                  {
                    D.62241 = sigc::operator<< <sigc::reference_wrapper<std::basic_ostringstream<char> >, sigc::internal::lambda_select1> (&D.61092, &_1); [return slot optimization]
                    try
                      {
                        D.63395 = sigc::operator<< <sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> > (&D.62241, &D.62244); [return slot optimization]
                        try
                          {
                            sigc::internal::lambda_core<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> >, true>::operator()<const char*> (&D.63395.D.63393, "hello world");
                          }
                        finally
                          {
                            sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> > >::~lambda (&D.63395);
                            D.63395 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.62241 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.61092 = {CLOBBER};
                  }
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.62244);
                D.62244 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.62243);
            D.62243 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.63614);
        try
          {
            std::basic_string<char>::basic_string (&D.63615, "hello world\n", &D.63614);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.63615);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.63615);
                D.63615 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.63614);
            D.63614 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.65261);
        try
          {
            std::basic_string<char>::basic_string (&D.65262, "\n", &D.65261);
            try
              {
                sigc::static_cast_<int, sigc::lambda<sigc::internal::lambda_select1> > (&_1);
                try
                  {
                    D.63616 = sigc::ref<std::basic_ostringstream<char> > (&result_stream);
                    try
                      {
                        D.65259 = sigc::operator<< <sigc::reference_wrapper<std::basic_ostringstream<char> >, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> > (&D.63616, &D.64431); [return slot optimization]
                        try
                          {
                            D.66081 = sigc::operator<< <sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, std::basic_string<char> > (&D.65259, &D.65262); [return slot optimization]
                            try
                              {
                                sigc::internal::lambda_core<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, std::basic_string<char> >, true>::operator()<double> (&D.66081.D.66079, 1.2339999999999999857891452847979962825775146484375e+0);
                              }
                            finally
                              {
                                sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, std::basic_string<char> > >::~lambda (&D.66081);
                                D.66081 = {CLOBBER};
                              }
                          }
                        finally
                          {
                            D.65259 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.63616 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.64431 = {CLOBBER};
                  }
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.65262);
                D.65262 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.65261);
            D.65261 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.66278);
        try
          {
            std::basic_string<char>::basic_string (&D.66279, "1\n", &D.66278);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.66279);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.66279);
                D.66279 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.66278);
            D.66278 = {CLOBBER};
          }
        D.67420 = sigc::var<char [2]> ("\n");
        try
          {
            D.66291 = 1;
            try
              {
                D.66285 = sigc::var<std::basic_ostringstream<char> > (&result_stream);
                try
                  {
                    D.67105 = sigc::operator<< <std::basic_ostringstream<char>&, int> (&D.66285, &D.66291); [return slot optimization]
                    try
                      {
                        D.68273 = sigc::operator<< <sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, int>, const char (&)[2]> (&D.67105, &D.67420); [return slot optimization]
                        try
                          {
                            sigc::internal::lambda_core<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, int>, const char (&)[2]>, true>::operator() (&D.68273.D.68271);
                          }
                        finally
                          {
                            D.68273 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.67105 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.66285 = {CLOBBER};
                  }
              }
            finally
              {
                D.66291 = {CLOBBER};
              }
          }
        finally
          {
            D.67420 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.68275);
        try
          {
            std::basic_string<char>::basic_string (&D.68276, "1\n", &D.68275);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.68276);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.68276);
                D.68276 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.68275);
            D.68275 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.68297);
        try
          {
            std::basic_string<char>::basic_string (&D.68298, "\n", &D.68297);
            try
              {
                D.68277 = sigc::var<std::basic_ostringstream<char> > (&result_stream);
                try
                  {
                    D.68295 = sigc::operator<< <std::basic_ostringstream<char>&, sigc::internal::lambda_select1> (&D.68277, &_1); [return slot optimization]
                    try
                      {
                        D.68299 = sigc::operator<< <sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> > (&D.68295, &D.68298); [return slot optimization]
                        try
                          {
                            sigc::internal::lambda_core<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> >, true>::operator()<const char*> (&D.68299.D.63393, "hello world");
                          }
                        finally
                          {
                            sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> > >::~lambda (&D.68299);
                            D.68299 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.68295 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.68277 = {CLOBBER};
                  }
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.68298);
                D.68298 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.68297);
            D.68297 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.68301);
        try
          {
            std::basic_string<char>::basic_string (&D.68302, "hello world\n", &D.68301);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.68302);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.68302);
                D.68302 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.68301);
            D.68301 = {CLOBBER};
          }
        sigc::slot<void>::slot (&sl1);
        try
          {
            {
              struct book guest_book;

              try
                {
                  std::allocator<char>::allocator (&D.68431);
                  try
                    {
                      std::basic_string<char>::basic_string (&D.68432, "karl", &D.68431);
                      try
                        {
                          {anonymous}::book::book (&guest_book, &D.68432);
                        }
                      finally
                        {
                          try
                            {
                              std::basic_string<char>::~basic_string (&D.68432);
                            }
                          catch
                            {
                              {anonymous}::book::~book (&guest_book);
                            }
                          D.68432 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      try
                        {
                          std::allocator<char>::~allocator (&D.68431);
                        }
                      catch
                        {
                          {anonymous}::book::~book (&guest_book);
                        }
                      D.68431 = {CLOBBER};
                    }
                  try
                    {
                      D.69620 = sigc::var<char [2]> ("\n");
                      try
                        {
                          D.68470 = sigc::ref<{anonymous}::book> (&guest_book);
                          try
                            {
                              D.68449 = sigc::var<std::basic_ostringstream<char> > (&result_stream);
                              try
                                {
                                  D.69619 = sigc::operator<< <std::basic_ostringstream<char>&, sigc::reference_wrapper<{anonymous}::book> > (&D.68449, &D.68470); [return slot optimization]
                                  try
                                    {
                                      D.70453 = sigc::operator<< <sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> (&D.69619, &D.69620); [return slot optimization]
                                      try
                                        {
                                          D.70749 = sigc::hide_return<sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > > (&D.70453); [return slot optimization]
                                          try
                                            {
                                              sigc::slot<void>::slot<sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > > > (&D.70762, &D.70749);
                                              try
                                                {
                                                  sigc::slot<void>::operator= (&sl1, &D.70762);
                                                }
                                              finally
                                                {
                                                  sigc::slot<void>::~slot (&D.70762);
                                                  D.70762 = {CLOBBER};
                                                }
                                            }
                                          finally
                                            {
                                              D.70749 = {CLOBBER};
                                            }
                                        }
                                      finally
                                        {
                                          D.70453 = {CLOBBER};
                                        }
                                    }
                                  finally
                                    {
                                      D.69619 = {CLOBBER};
                                    }
                                }
                              finally
                                {
                                  D.68449 = {CLOBBER};
                                }
                            }
                          finally
                            {
                              D.68470 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          D.69620 = {CLOBBER};
                        }
                      sigc::slot0<void>::operator() (&sl1.D.68395);
                      std::allocator<char>::allocator (&D.70765);
                      try
                        {
                          std::basic_string<char>::basic_string (&D.70766, "karl\n", &D.70765);
                          try
                            {
                              TestUtilities::check_result (util, &result_stream, &D.70766);
                            }
                          finally
                            {
                              std::basic_string<char>::~basic_string (&D.70766);
                              D.70766 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          std::allocator<char>::~allocator (&D.70765);
                          D.70765 = {CLOBBER};
                        }
                    }
                  finally
                    {
                      {anonymous}::book::~book (&guest_book);
                    }
                }
              finally
                {
                  guest_book = {CLOBBER};
                }
            }
            sigc::slot0<void>::operator() (&sl1.D.68395);
            std::allocator<char>::allocator (&D.70768);
            try
              {
                std::basic_string<char>::basic_string (&D.70769, "", &D.70768);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.70769);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.70769);
                    D.70769 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.70768);
                D.70768 = {CLOBBER};
              }
            D.70777 = foo;
            try
              {
                D.72576 = sigc::group<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> > (&D.70777, _1, _2); [return slot optimization]
                try
                  {
                    D.93404 = sigc::internal::lambda_core<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> >, true>::operator()<int, int> (&D.72576.D.72574, 1, 2);
                    std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.93404);
                  }
                finally
                  {
                    D.72576 = {CLOBBER};
                  }
              }
            finally
              {
                D.70777 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.72689);
            try
              {
                std::basic_string<char>::basic_string (&D.72690, "foo(int 1, int 2) 6", &D.72689);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.72690);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.72690);
                    D.72690 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.72689);
                D.72689 = {CLOBBER};
              }
            D.72697 = foo;
            try
              {
                D.73516 = sigc::group<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select2>, sigc::lambda<sigc::internal::lambda_select1> > (&D.72697, _2, _1); [return slot optimization]
                try
                  {
                    D.93405 = sigc::internal::lambda_core<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select2>, sigc::lambda<sigc::internal::lambda_select1> >, true>::operator()<int, int> (&D.73516.D.73514, 1, 2);
                    std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.93405);
                  }
                finally
                  {
                    D.73516 = {CLOBBER};
                  }
              }
            finally
              {
                D.72697 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.73558);
            try
              {
                std::basic_string<char>::basic_string (&D.73559, "foo(int 2, int 1) 9", &D.73558);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.73559);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.73559);
                    D.73559 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.73558);
                D.73558 = {CLOBBER};
              }
            D.93406 = sigc::ref<{anonymous}::bar> (&the_bar);
            D.93407.__pfn = test;
            D.93407.__delta = 0;
            D.73596 = sigc::mem_fun<int, int, int, {anonymous}::bar> (D.93407);
            try
              {
                D.75328 = sigc::group<sigc::mem_functor2<int, {anonymous}::bar, int, int>, sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2>, sigc::lambda<sigc::internal::lambda_select3> > (&D.73596, _1, _2, _3); [return slot optimization]
                try
                  {
                    D.93408 = sigc::internal::lambda_core<sigc::lambda_group3<sigc::mem_functor2<int, {anonymous}::bar, int, int>, sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2>, sigc::lambda<sigc::internal::lambda_select3> >, true>::operator()<sigc::reference_wrapper<{anonymous}::bar>, int, int> (&D.75328.D.75326, D.93406, 1, 2);
                    std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.93408);
                  }
                finally
                  {
                    D.75328 = {CLOBBER};
                  }
              }
            finally
              {
                D.73596 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.75503);
            try
              {
                std::basic_string<char>::basic_string (&D.75504, "bar::test(int 1, int 2) 6", &D.75503);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.75504);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.75504);
                    D.75504 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.75503);
                D.75503 = {CLOBBER};
              }
            D.75511 = foo;
            try
              {
                D.76329 = sigc::group<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, int> (&D.75511, _1, 2); [return slot optimization]
                try
                  {
                    D.93409 = sigc::internal::lambda_core<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, int>, true>::operator()<int> (&D.76329.D.76327, 1);
                    std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.93409);
                  }
                finally
                  {
                    D.76329 = {CLOBBER};
                  }
              }
            finally
              {
                D.75511 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.76410);
            try
              {
                std::basic_string<char>::basic_string (&D.76411, "foo(int 1, int 2) 6", &D.76410);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.76411);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.76411);
                    D.76411 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.76410);
                D.76410 = {CLOBBER};
              }
            D.76418 = foo;
            try
              {
                D.77235 = sigc::group<int (*)(int, int), int, int> (&D.76418, 1, 2); [return slot optimization]
                try
                  {
                    D.93410 = sigc::internal::lambda_core<sigc::lambda_group2<int (*)(int, int), int, int>, true>::operator() (&D.77235.D.77233);
                    std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.93410);
                  }
                finally
                  {
                    D.77235 = {CLOBBER};
                  }
              }
            finally
              {
                D.76418 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.77237);
            try
              {
                std::basic_string<char>::basic_string (&D.77238, "foo(int 1, int 2) 6", &D.77237);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.77238);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.77238);
                    D.77238 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.77237);
                D.77237 = {CLOBBER};
              }
            D.77265 = sigc::ptr_fun<int, void> (foo_void);
            try
              {
                D.78518 = sigc::group<sigc::pointer_functor1<int, void>, int> (&D.77265, 1); [return slot optimization]
                try
                  {
                    sigc::internal::lambda_core<sigc::lambda_group1<sigc::pointer_functor1<int, void>, int>, true>::operator() (&D.78518.D.78516);
                  }
                finally
                  {
                    D.78518 = {CLOBBER};
                  }
              }
            finally
              {
                D.77265 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.78520);
            try
              {
                std::basic_string<char>::basic_string (&D.78521, "foo_void(int 1)", &D.78520);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.78521);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.78521);
                    D.78521 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.78520);
                D.78520 = {CLOBBER};
              }
            sigc::slot<void>::slot (&sl2);
            try
              {
                {
                  struct book guest_book;

                  try
                    {
                      std::allocator<char>::allocator (&D.78525);
                      try
                        {
                          std::basic_string<char>::basic_string (&D.78526, "karl", &D.78525);
                          try
                            {
                              {anonymous}::book::book (&guest_book, &D.78526);
                            }
                          finally
                            {
                              try
                                {
                                  std::basic_string<char>::~basic_string (&D.78526);
                                }
                              catch
                                {
                                  {anonymous}::book::~book (&guest_book);
                                }
                              D.78526 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          try
                            {
                              std::allocator<char>::~allocator (&D.78525);
                            }
                          catch
                            {
                              {anonymous}::book::~book (&guest_book);
                            }
                          D.78525 = {CLOBBER};
                        }
                      try
                        {
                          D.93411 = sigc::ref<{anonymous}::book> (&guest_book);
                          D.78533 = egon;
                          try
                            {
                              D.79852 = sigc::group<void (*)(std::basic_string<char>&), sigc::reference_wrapper<{anonymous}::book> > (&D.78533, D.93411); [return slot optimization]
                              try
                                {
                                  sigc::slot<void>::slot<sigc::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> > > (&D.79862, &D.79852);
                                  try
                                    {
                                      sigc::slot<void>::operator= (&sl2, &D.79862);
                                    }
                                  finally
                                    {
                                      sigc::slot<void>::~slot (&D.79862);
                                      D.79862 = {CLOBBER};
                                    }
                                }
                              finally
                                {
                                  D.79852 = {CLOBBER};
                                }
                            }
                          finally
                            {
                              D.78533 = {CLOBBER};
                            }
                          sigc::slot0<void>::operator() (&sl2.D.68395);
                          std::allocator<char>::allocator (&D.79864);
                          try
                            {
                              std::basic_string<char>::basic_string (&D.79865, "egon(string \'karl\')", &D.79864);
                              try
                                {
                                  TestUtilities::check_result (util, &result_stream, &D.79865);
                                }
                              finally
                                {
                                  std::basic_string<char>::~basic_string (&D.79865);
                                  D.79865 = {CLOBBER};
                                }
                            }
                          finally
                            {
                              std::allocator<char>::~allocator (&D.79864);
                              D.79864 = {CLOBBER};
                            }
                          D.93412 = {anonymous}::book::operator std::string& (&guest_book);
                          std::operator<< <char, std::char_traits<char>, std::allocator<char> > (&result_stream.D.22312, D.93412);
                          std::allocator<char>::allocator (&D.79867);
                          try
                            {
                              std::basic_string<char>::basic_string (&D.79868, "karl", &D.79867);
                              try
                                {
                                  TestUtilities::check_result (util, &result_stream, &D.79868);
                                }
                              finally
                                {
                                  std::basic_string<char>::~basic_string (&D.79868);
                                  D.79868 = {CLOBBER};
                                }
                            }
                          finally
                            {
                              std::allocator<char>::~allocator (&D.79867);
                              D.79867 = {CLOBBER};
                            }
                        }
                      finally
                        {
                          {anonymous}::book::~book (&guest_book);
                        }
                    }
                  finally
                    {
                      guest_book = {CLOBBER};
                    }
                }
                sigc::slot0<void>::operator() (&sl2.D.68395);
                std::allocator<char>::allocator (&D.79870);
                try
                  {
                    std::basic_string<char>::basic_string (&D.79871, "", &D.79870);
                    try
                      {
                        TestUtilities::check_result (util, &result_stream, &D.79871);
                      }
                    finally
                      {
                        std::basic_string<char>::~basic_string (&D.79871);
                        D.79871 = {CLOBBER};
                      }
                  }
                finally
                  {
                    std::allocator<char>::~allocator (&D.79870);
                    D.79870 = {CLOBBER};
                  }
                D.79872 = foo;
                try
                  {
                    D.79875 = sigc::group<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> > (&D.79872, _1, _2); [return slot optimization]
                    try
                      {
                        D.93413 = sigc::internal::lambda_core<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> >, true>::operator()<int, int, int> (&D.79875.D.72574, 1, 2, 3);
                        std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.93413);
                      }
                    finally
                      {
                        D.79875 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.79872 = {CLOBBER};
                  }
                std::allocator<char>::allocator (&D.79954);
                try
                  {
                    std::basic_string<char>::basic_string (&D.79955, "foo(int 1, int 2) 6", &D.79954);
                    try
                      {
                        TestUtilities::check_result (util, &result_stream, &D.79955);
                      }
                    finally
                      {
                        std::basic_string<char>::~basic_string (&D.79955);
                        D.79955 = {CLOBBER};
                      }
                  }
                finally
                  {
                    std::allocator<char>::~allocator (&D.79954);
                    D.79954 = {CLOBBER};
                  }
                D.79956 = sigc::ptr_fun<int, void> (foo_void);
                try
                  {
                    D.80773 = sigc::group<sigc::pointer_functor1<int, void>, sigc::lambda<sigc::internal::lambda_select2> > (&D.79956, _2); [return slot optimization]
                    try
                      {
                        sigc::internal::lambda_core<sigc::lambda_group1<sigc::pointer_functor1<int, void>, sigc::lambda<sigc::internal::lambda_select2> >, true>::operator()<int, int> (&D.80773.D.80771, 1, 2);
                      }
                    finally
                      {
                        D.80773 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.79956 = {CLOBBER};
                  }
                std::allocator<char>::allocator (&D.80837);
                try
                  {
                    std::basic_string<char>::basic_string (&D.80838, "foo_void(int 2)", &D.80837);
                    try
                      {
                        TestUtilities::check_result (util, &result_stream, &D.80838);
                      }
                    finally
                      {
                        std::basic_string<char>::~basic_string (&D.80838);
                        D.80838 = {CLOBBER};
                      }
                  }
                finally
                  {
                    std::allocator<char>::~allocator (&D.80837);
                    D.80837 = {CLOBBER};
                  }
                D.80839 = foo;
                try
                  {
                    D.93414 = sigc::group<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> > (&D.80839, _1, _2); [return slot optimization]
                    D.80853 = foo;
                    try
                      {
                        D.82127 = sigc::group<int (*)(int, int), sigc::lambda<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> > >, sigc::lambda<sigc::internal::lambda_select3> > (&D.80853, D.93414, _3); [return slot optimization]
                        try
                          {
                            D.93415 = sigc::internal::lambda_core<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> > >, sigc::lambda<sigc::internal::lambda_select3> >, true>::operator()<int, int, int> (&D.82127.D.82125, 1, 2, 3);
                            std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.93415);
                          }
                        finally
                          {
                            D.82127 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.80853 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.80839 = {CLOBBER};
                  }
                std::allocator<char>::allocator (&D.82228);
                try
                  {
                    std::basic_string<char>::basic_string (&D.82229, "foo(int 1, int 2) foo(int 6, int 3) 27", &D.82228);
                    try
                      {
                        TestUtilities::check_result (util, &result_stream, &D.82229);
                      }
                    finally
                      {
                        std::basic_string<char>::~basic_string (&D.82229);
                        D.82229 = {CLOBBER};
                      }
                  }
                finally
                  {
                    std::allocator<char>::~allocator (&D.82228);
                    D.82228 = {CLOBBER};
                  }
                sigc::static_cast_<int, sigc::lambda<sigc::internal::lambda_select1> > (&_1);
                D.82241 = foo;
                try
                  {
                    D.83514 = sigc::group<int (*)(int, int), sigc::lambda<sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, int> (&D.82241, D.93416, 2); [return slot optimization]
                    try
                      {
                        D.93417 = sigc::internal::lambda_core<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, int>, true>::operator()<double> (&D.83514.D.83512, 1.2339999999999999857891452847979962825775146484375e+0);
                        std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.93417);
                      }
                    finally
                      {
                        D.83514 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.82241 = {CLOBBER};
                  }
                std::allocator<char>::allocator (&D.83613);
                try
                  {
                    std::basic_string<char>::basic_string (&D.83614, "foo(int 1, int 2) 6", &D.83613);
                    try
                      {
                        TestUtilities::check_result (util, &result_stream, &D.83614);
                      }
                    finally
                      {
                        std::basic_string<char>::~basic_string (&D.83614);
                        D.83614 = {CLOBBER};
                      }
                  }
                finally
                  {
                    std::allocator<char>::~allocator (&D.83613);
                    D.83613 = {CLOBBER};
                  }
                D.93419 = TestUtilities::get_result_and_delete_instance ();
                if (D.93419 != 0) goto <D.93420>; else goto <D.93421>;
                <D.93420>:
                iftmp.5 = 0;
                goto <D.93422>;
                <D.93421>:
                iftmp.5 = 1;
                <D.93422>:
                D.93358 = iftmp.5;
                return D.93358;
              }
            finally
              {
                sigc::slot<void>::~slot (&sl2);
              }
          }
        finally
          {
            sigc::slot<void>::~slot (&sl1);
          }
      }
    finally
      {
        a = {CLOBBER};
        b = {CLOBBER};
        c = {CLOBBER};
        sl1 = {CLOBBER};
        the_bar = {CLOBBER};
        sl2 = {CLOBBER};
      }
  }
  D.93358 = 0;
  return D.93358;
}


void {anonymous}::egon(std::string&) (struct string & str)
{
  struct basic_ostream & D.93642;
  struct basic_ostream & D.93643;

  D.93642 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "egon(string \'");
  D.93643 = std::operator<< <char, std::char_traits<char>, std::allocator<char> > (D.93642, str);
  std::operator<< <std::char_traits<char> > (D.93643, "\')");
  std::basic_string<char>::operator= (str, "egon was here");
}


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

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


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

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


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

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


void {anonymous}::foo_void(int) (int i)
{
  struct basic_ostream & D.93655;
  struct basic_ostream & D.93656;

  D.93655 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "foo_void(int ");
  D.93656 = std::basic_ostream<char>::operator<< (D.93655, i);
  std::operator<< <std::char_traits<char> > (D.93656, ")");
}


int {anonymous}::bar::test(int, int) (struct bar * const this, int i, int j)
{
  struct basic_ostream & D.93659;
  struct basic_ostream & D.93660;
  struct basic_ostream & D.93661;
  struct basic_ostream & D.93662;
  int D.93663;
  int D.93664;

  D.93659 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "bar::test(int ");
  D.93660 = std::basic_ostream<char>::operator<< (D.93659, i);
  D.93661 = std::operator<< <std::char_traits<char> > (D.93660, ", int ");
  D.93662 = std::basic_ostream<char>::operator<< (D.93661, j);
  std::operator<< <std::char_traits<char> > (D.93662, ") ");
  D.93664 = i * 4;
  D.93663 = D.93664 + j;
  return D.93663;
}


int {anonymous}::foo(int, int) (int i, int j)
{
  struct basic_ostream & D.93670;
  struct basic_ostream & D.93671;
  struct basic_ostream & D.93672;
  struct basic_ostream & D.93673;
  int D.93674;
  int D.93675;

  D.93670 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "foo(int ");
  D.93671 = std::basic_ostream<char>::operator<< (D.93670, i);
  D.93672 = std::operator<< <std::char_traits<char> > (D.93671, ", int ");
  D.93673 = std::basic_ostream<char>::operator<< (D.93672, j);
  std::operator<< <std::char_traits<char> > (D.93673, ") ");
  D.93675 = i * 4;
  D.93674 = D.93675 + j;
  return D.93674;
}


sigc::lambda<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, T_arg1, T_arg2> > sigc::operator+(const sigc::lambda<T_type>&, const sigc::lambda<T_type1>&) [with T_arg1 = sigc::internal::lambda_select1; T_arg2 = sigc::internal::lambda_select2] (const struct lambda & a1, const struct lambda & a2)
{
  struct lambda D.93681;
  struct lambda D.83754;
  struct operator_type D.83744;
  const struct lambda_select2 * D.93682;
  const struct lambda_select1 * D.93683;
  typedef struct operator_type operator_type;

  D.93682 = &a2->D.40511.value_;
  D.93683 = &a1->D.40074.value_;
  sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, sigc::internal::lambda_select2>::lambda_operator (&D.83744, D.93683, D.93682);
  try
    {
      sigc::lambda<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, sigc::internal::lambda_select2> >::lambda (&D.83754, &D.83744);
      try
        {
          return D.93681;
        }
      finally
        {
          D.83754 = {CLOBBER};
        }
    }
  finally
    {
      D.83744 = {CLOBBER};
    }
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::arithmetic<sigc::plus>; T_type1 = sigc::internal::lambda_select1; T_type2 = sigc::internal::lambda_select2; typename sigc::type_trait<T_derived>::take = const sigc::internal::lambda_select1&; typename sigc::type_trait<T_arg3>::take = const sigc::internal::lambda_select2&] (struct lambda_operator * const this, const struct lambda_select1 & a1, const struct lambda_select2 & a2)
{
  sigc::lambda_base::lambda_base (this);
}


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


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


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

}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, sigc::internal::lambda_select2>; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, sigc::internal::lambda_select2>&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.93688;

  D.93688 = &this->D.41348;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, sigc::internal::lambda_select2>, true>::lambda_core (D.93688, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, sigc::internal::lambda_select2>] (struct lambda_core * const this, const struct lambda_operator & v)
{
  sigc::lambda_base::lambda_base (this);
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2) const [with T_arg1 = int; T_arg2 = int; T_type = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, sigc::internal::lambda_select2>; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct lambda_core * const this, int _A_1, int _A_2)
{
  type D.93689;
  const struct lambda_operator * D.93690;

  D.93690 = &this->value_;
  D.93689 = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, sigc::internal::lambda_select2>::operator()<int&, int&> (D.93690, &_A_1, &_A_2);
  return D.93689;
}


typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()(T_arg1, T_arg2) const [with T_arg1 = int&; T_arg2 = int&; T_action = sigc::arithmetic<sigc::plus>; T_type1 = sigc::internal::lambda_select1; T_type2 = sigc::internal::lambda_select2; typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct lambda_operator * const this, int & _A_1, int & _A_2)
{
  type D.93693;
  const struct arg2_type * D.93694;
  int & D.93695;
  const struct arg1_type * D.93696;
  int & D.93697;

  D.93694 = &this->arg2_;
  D.93695 = sigc::internal::lambda_select2::operator()<int&, int&> (D.93694, _A_1, _A_2);
  D.93696 = &this->arg1_;
  D.93697 = sigc::internal::lambda_select1::operator()<int&, int&> (D.93696, _A_1, _A_2);
  D.93693 = sigc::lambda_action<sigc::arithmetic<sigc::plus> >::do_action<int&, int&> (D.93697, D.93695);
  return D.93693;
}


T_arg2 sigc::internal::lambda_select2::operator()(T_arg1, T_arg2) const [with T_arg1 = int&; T_arg2 = int&] (const struct lambda_select2 * const this, int & D.87316, int & _A_2)
{
  int & D.93699;

  D.93699 = _A_2;
  return D.93699;
}


T_arg1 sigc::internal::lambda_select1::operator()(T_arg1, T_arg2) const [with T_arg1 = int&; T_arg2 = int&] (const struct lambda_select1 * const this, int & _A_1, int & D.87313)
{
  int & D.93701;

  D.93701 = _A_1;
  return D.93701;
}


static typename sigc::lambda_action_deduce_result_type<sigc::arithmetic<sigc::plus>, T_arg1, T_arg2>::type sigc::lambda_action<sigc::arithmetic<sigc::plus> >::do_action(T_arg1, T_arg2) [with T_arg1 = int&; T_arg2 = int&; typename sigc::lambda_action_deduce_result_type<sigc::arithmetic<sigc::plus>, T_arg1, T_arg2>::type = int] (int & _A_1, int & _A_2)
{
  type D.93703;
  int D.93704;
  int D.93705;

  D.93704 = *_A_1;
  D.93705 = *_A_2;
  D.93703 = D.93704 + D.93705;
  return D.93703;
}


sigc::lambda<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, T_arg1, typename sigc::unwrap_reference<T_arg2>::type> > sigc::operator+(const sigc::lambda<T_type>&, const T_arg2&) [with T_arg1 = sigc::internal::lambda_select1; T_arg2 = int; typename sigc::unwrap_reference<T_arg2>::type = int] (const struct lambda & a1, const int & a2)
{
  struct lambda D.93707;
  struct lambda D.83893;
  struct operator_type D.83883;
  const struct lambda_select1 * D.93708;
  typedef struct operator_type operator_type;

  D.93708 = &a1->D.40074.value_;
  sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, int>::lambda_operator (&D.83883, D.93708, a2);
  try
    {
      sigc::lambda<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, int> >::lambda (&D.83893, &D.83883);
      try
        {
          D.93707 = D.83893;
          return D.93707;
        }
      finally
        {
          D.83893 = {CLOBBER};
        }
    }
  finally
    {
      D.83883 = {CLOBBER};
    }
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::arithmetic<sigc::plus>; T_type1 = sigc::internal::lambda_select1; T_type2 = int; typename sigc::type_trait<T_derived>::take = const sigc::internal::lambda_select1&; typename sigc::type_trait<T_arg3>::take = const int&] (struct lambda_operator * const this, const struct lambda_select1 & a1, const int & a2)
{
  struct arg2_type * D.93713;

  sigc::lambda_base::lambda_base (this);
  D.93713 = &this->arg2_;
  sigc::lambda<int>::lambda (D.93713, a2);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = int; typename sigc::type_trait<T_base>::take = const int&] (struct lambda * const this, const int & v)
{
  struct lambda_core * D.93714;

  D.93714 = &this->D.41753;
  sigc::internal::lambda_core<int, false>::lambda_core (D.93714, v);
}


sigc::internal::lambda_core<T_type, false>::lambda_core(typename sigc::type_trait<T_base>::take) [with T_type = int; typename sigc::type_trait<T_base>::take = const int&] (struct lambda_core * const this, const int & v)
{
  int D.93715;

  sigc::lambda_base::lambda_base (this);
  D.93715 = *v;
  this->value_ = D.93715;
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, int>; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, int>&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.93716;

  D.93716 = &this->D.42547;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, int>, true>::lambda_core (D.93716, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, int>] (struct lambda_core * const this, const struct lambda_operator & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2) const [with T_arg1 = int; T_arg2 = int; T_type = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, int>; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct lambda_core * const this, int _A_1, int _A_2)
{
  type D.93717;
  const struct lambda_operator * D.93718;

  D.93718 = &this->value_;
  D.93717 = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, int>::operator()<int&, int&> (D.93718, &_A_1, &_A_2);
  return D.93717;
}


typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()(T_arg1, T_arg2) const [with T_arg1 = int&; T_arg2 = int&; T_action = sigc::arithmetic<sigc::plus>; T_type1 = sigc::internal::lambda_select1; T_type2 = int; typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct lambda_operator * const this, int & _A_1, int & _A_2)
{
  type D.93721;
  const struct lambda_core * D.93722;
  int D.93723;
  const struct arg1_type * D.93724;
  int & D.93725;

  D.93722 = &this->arg2_.D.41753;
  D.93723 = sigc::internal::lambda_core<int, false>::operator()<int&, int&> (D.93722, _A_1, _A_2);
  D.93724 = &this->arg1_;
  D.93725 = sigc::internal::lambda_select1::operator()<int&, int&> (D.93724, _A_1, _A_2);
  D.93721 = sigc::lambda_action<sigc::arithmetic<sigc::plus> >::do_action<int&, int> (D.93725, D.93723);
  return D.93721;
}


sigc::internal::lambda_core<T_type, false>::result_type sigc::internal::lambda_core<T_type, false>::operator()(T_arg1, T_arg2) const [with T_arg1 = int&; T_arg2 = int&; T_type = int; sigc::internal::lambda_core<T_type, false>::result_type = int] (const struct lambda_core * const this, int & D.87380, int & D.87381)
{
  result_type D.93727;

  D.93727 = this->value_;
  return D.93727;
}


static typename sigc::lambda_action_deduce_result_type<sigc::arithmetic<sigc::plus>, T_arg1, T_arg2>::type sigc::lambda_action<sigc::arithmetic<sigc::plus> >::do_action(T_arg1, T_arg2) [with T_arg1 = int&; T_arg2 = int; typename sigc::lambda_action_deduce_result_type<sigc::arithmetic<sigc::plus>, T_arg1, T_arg2>::type = int] (int & _A_1, int _A_2)
{
  type D.93729;
  int D.93730;

  D.93730 = *_A_1;
  D.93729 = D.93730 + _A_2;
  return D.93729;
}


sigc::lambda<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, T_arg1, typename sigc::unwrap_reference<T_arg2>::type> > sigc::operator+(const sigc::lambda<T_type>&, const T_arg2&) [with T_arg1 = sigc::internal::lambda_select2; T_arg2 = int; typename sigc::unwrap_reference<T_arg2>::type = int] (const struct lambda & a1, const int & a2)
{
  struct lambda D.93732;
  struct lambda D.84022;
  struct operator_type D.84012;
  const struct lambda_select2 * D.93733;
  typedef struct operator_type operator_type;

  D.93733 = &a1->D.40511.value_;
  sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select2, int>::lambda_operator (&D.84012, D.93733, a2);
  try
    {
      sigc::lambda<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select2, int> >::lambda (&D.84022, &D.84012);
      try
        {
          D.93732 = D.84022;
          return D.93732;
        }
      finally
        {
          D.84022 = {CLOBBER};
        }
    }
  finally
    {
      D.84012 = {CLOBBER};
    }
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::arithmetic<sigc::plus>; T_type1 = sigc::internal::lambda_select2; T_type2 = int; typename sigc::type_trait<T_derived>::take = const sigc::internal::lambda_select2&; typename sigc::type_trait<T_arg3>::take = const int&] (struct lambda_operator * const this, const struct lambda_select2 & a1, const int & a2)
{
  struct arg2_type * D.93738;

  sigc::lambda_base::lambda_base (this);
  D.93738 = &this->arg2_;
  sigc::lambda<int>::lambda (D.93738, a2);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select2, int>; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select2, int>&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.93739;

  D.93739 = &this->D.43431;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select2, int>, true>::lambda_core (D.93739, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select2, int>] (struct lambda_core * const this, const struct lambda_operator & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2) const [with T_arg1 = int; T_arg2 = int; T_type = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select2, int>; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct lambda_core * const this, int _A_1, int _A_2)
{
  type D.93740;
  const struct lambda_operator * D.93741;

  D.93741 = &this->value_;
  D.93740 = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select2, int>::operator()<int&, int&> (D.93741, &_A_1, &_A_2);
  return D.93740;
}


typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()(T_arg1, T_arg2) const [with T_arg1 = int&; T_arg2 = int&; T_action = sigc::arithmetic<sigc::plus>; T_type1 = sigc::internal::lambda_select2; T_type2 = int; typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct lambda_operator * const this, int & _A_1, int & _A_2)
{
  type D.93744;
  const struct lambda_core * D.93745;
  int D.93746;
  const struct arg1_type * D.93747;
  int & D.93748;

  D.93745 = &this->arg2_.D.41753;
  D.93746 = sigc::internal::lambda_core<int, false>::operator()<int&, int&> (D.93745, _A_1, _A_2);
  D.93747 = &this->arg1_;
  D.93748 = sigc::internal::lambda_select2::operator()<int&, int&> (D.93747, _A_1, _A_2);
  D.93744 = sigc::lambda_action<sigc::arithmetic<sigc::plus> >::do_action<int&, int> (D.93748, D.93746);
  return D.93744;
}


sigc::lambda<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, typename sigc::unwrap_reference<T_type>::type, T_arg2> > sigc::operator+(const T_arg1&, const sigc::lambda<T_type1>&) [with T_arg1 = int; T_arg2 = sigc::internal::lambda_select1; typename sigc::unwrap_reference<T_type>::type = int] (const int & a1, const struct lambda & a2)
{
  struct lambda D.93750;
  struct lambda D.84151;
  struct operator_type D.84141;
  const struct lambda_select1 * D.93751;
  typedef struct operator_type operator_type;

  D.93751 = &a2->D.40074.value_;
  sigc::lambda_operator<sigc::arithmetic<sigc::plus>, int, sigc::internal::lambda_select1>::lambda_operator (&D.84141, a1, D.93751);
  try
    {
      sigc::lambda<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, int, sigc::internal::lambda_select1> >::lambda (&D.84151, &D.84141);
      try
        {
          D.93750 = D.84151;
          return D.93750;
        }
      finally
        {
          D.84151 = {CLOBBER};
        }
    }
  finally
    {
      D.84141 = {CLOBBER};
    }
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::arithmetic<sigc::plus>; T_type1 = int; T_type2 = sigc::internal::lambda_select1; typename sigc::type_trait<T_derived>::take = const int&; typename sigc::type_trait<T_arg3>::take = const sigc::internal::lambda_select1&] (struct lambda_operator * const this, const int & a1, const struct lambda_select1 & a2)
{
  struct arg1_type * D.93756;

  sigc::lambda_base::lambda_base (this);
  D.93756 = &this->arg1_;
  sigc::lambda<int>::lambda (D.93756, a1);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, int, sigc::internal::lambda_select1>; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::arithmetic<sigc::plus>, int, sigc::internal::lambda_select1>&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.93757;

  D.93757 = &this->D.44297;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, int, sigc::internal::lambda_select1>, true>::lambda_core (D.93757, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, int, sigc::internal::lambda_select1>] (struct lambda_core * const this, const struct lambda_operator & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2) const [with T_arg1 = int; T_arg2 = int; T_type = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, int, sigc::internal::lambda_select1>; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct lambda_core * const this, int _A_1, int _A_2)
{
  type D.93758;
  const struct lambda_operator * D.93759;

  D.93759 = &this->value_;
  D.93758 = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, int, sigc::internal::lambda_select1>::operator()<int&, int&> (D.93759, &_A_1, &_A_2);
  return D.93758;
}


typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()(T_arg1, T_arg2) const [with T_arg1 = int&; T_arg2 = int&; T_action = sigc::arithmetic<sigc::plus>; T_type1 = int; T_type2 = sigc::internal::lambda_select1; typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct lambda_operator * const this, int & _A_1, int & _A_2)
{
  type D.93762;
  const struct arg2_type * D.93763;
  int & D.93764;
  const struct lambda_core * D.93765;
  int D.93766;

  D.93763 = &this->arg2_;
  D.93764 = sigc::internal::lambda_select1::operator()<int&, int&> (D.93763, _A_1, _A_2);
  D.93765 = &this->arg1_.D.41753;
  D.93766 = sigc::internal::lambda_core<int, false>::operator()<int&, int&> (D.93765, _A_1, _A_2);
  D.93762 = sigc::lambda_action<sigc::arithmetic<sigc::plus> >::do_action<int, int&> (D.93766, D.93764);
  return D.93762;
}


static typename sigc::lambda_action_deduce_result_type<sigc::arithmetic<sigc::plus>, T_arg1, T_arg2>::type sigc::lambda_action<sigc::arithmetic<sigc::plus> >::do_action(T_arg1, T_arg2) [with T_arg1 = int; T_arg2 = int&; typename sigc::lambda_action_deduce_result_type<sigc::arithmetic<sigc::plus>, T_arg1, T_arg2>::type = int] (int _A_1, int & _A_2)
{
  type D.93768;
  int D.93769;

  D.93769 = *_A_2;
  D.93768 = D.93769 + _A_1;
  return D.93768;
}


sigc::lambda<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, typename sigc::unwrap_reference<T_type>::type, T_arg2> > sigc::operator+(const T_arg1&, const sigc::lambda<T_type1>&) [with T_arg1 = int; T_arg2 = sigc::internal::lambda_select2; typename sigc::unwrap_reference<T_type>::type = int] (const int & a1, const struct lambda & a2)
{
  struct lambda D.93771;
  struct lambda D.84280;
  struct operator_type D.84270;
  const struct lambda_select2 * D.93772;
  typedef struct operator_type operator_type;

  D.93772 = &a2->D.40511.value_;
  sigc::lambda_operator<sigc::arithmetic<sigc::plus>, int, sigc::internal::lambda_select2>::lambda_operator (&D.84270, a1, D.93772);
  try
    {
      sigc::lambda<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, int, sigc::internal::lambda_select2> >::lambda (&D.84280, &D.84270);
      try
        {
          D.93771 = D.84280;
          return D.93771;
        }
      finally
        {
          D.84280 = {CLOBBER};
        }
    }
  finally
    {
      D.84270 = {CLOBBER};
    }
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::arithmetic<sigc::plus>; T_type1 = int; T_type2 = sigc::internal::lambda_select2; typename sigc::type_trait<T_derived>::take = const int&; typename sigc::type_trait<T_arg3>::take = const sigc::internal::lambda_select2&] (struct lambda_operator * const this, const int & a1, const struct lambda_select2 & a2)
{
  struct arg1_type * D.93777;

  sigc::lambda_base::lambda_base (this);
  D.93777 = &this->arg1_;
  sigc::lambda<int>::lambda (D.93777, a1);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, int, sigc::internal::lambda_select2>; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::arithmetic<sigc::plus>, int, sigc::internal::lambda_select2>&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.93778;

  D.93778 = &this->D.45163;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, int, sigc::internal::lambda_select2>, true>::lambda_core (D.93778, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, int, sigc::internal::lambda_select2>] (struct lambda_core * const this, const struct lambda_operator & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2) const [with T_arg1 = int; T_arg2 = int; T_type = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, int, sigc::internal::lambda_select2>; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct lambda_core * const this, int _A_1, int _A_2)
{
  type D.93779;
  const struct lambda_operator * D.93780;

  D.93780 = &this->value_;
  D.93779 = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, int, sigc::internal::lambda_select2>::operator()<int&, int&> (D.93780, &_A_1, &_A_2);
  return D.93779;
}


typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()(T_arg1, T_arg2) const [with T_arg1 = int&; T_arg2 = int&; T_action = sigc::arithmetic<sigc::plus>; T_type1 = int; T_type2 = sigc::internal::lambda_select2; typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct lambda_operator * const this, int & _A_1, int & _A_2)
{
  type D.93783;
  const struct arg2_type * D.93784;
  int & D.93785;
  const struct lambda_core * D.93786;
  int D.93787;

  D.93784 = &this->arg2_;
  D.93785 = sigc::internal::lambda_select2::operator()<int&, int&> (D.93784, _A_1, _A_2);
  D.93786 = &this->arg1_.D.41753;
  D.93787 = sigc::internal::lambda_core<int, false>::operator()<int&, int&> (D.93786, _A_1, _A_2);
  D.93783 = sigc::lambda_action<sigc::arithmetic<sigc::plus> >::do_action<int, int&> (D.93787, D.93785);
  return D.93783;
}


sigc::lambda<sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, T_arg1, T_arg2> > sigc::operator*(const sigc::lambda<T_type>&, const sigc::lambda<T_type1>&) [with T_arg1 = sigc::internal::lambda_select2; T_arg2 = sigc::internal::lambda_select3] (const struct lambda & a1, const struct lambda & a2)
{
  struct lambda D.93789;
  struct lambda D.84409;
  struct operator_type D.84399;
  const struct lambda_select3 * D.93790;
  const struct lambda_select2 * D.93791;
  typedef struct operator_type operator_type;

  D.93790 = &a2->D.45646.value_;
  D.93791 = &a1->D.40511.value_;
  sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::internal::lambda_select2, sigc::internal::lambda_select3>::lambda_operator (&D.84399, D.93791, D.93790);
  try
    {
      sigc::lambda<sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::internal::lambda_select2, sigc::internal::lambda_select3> >::lambda (&D.84409, &D.84399);
      try
        {
          return D.93789;
        }
      finally
        {
          D.84409 = {CLOBBER};
        }
    }
  finally
    {
      D.84399 = {CLOBBER};
    }
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::arithmetic<sigc::multiplies>; T_type1 = sigc::internal::lambda_select2; T_type2 = sigc::internal::lambda_select3; typename sigc::type_trait<T_derived>::take = const sigc::internal::lambda_select2&; typename sigc::type_trait<T_arg3>::take = const sigc::internal::lambda_select3&] (struct lambda_operator * const this, const struct lambda_select2 & a1, const struct lambda_select3 & a2)
{
  sigc::lambda_base::lambda_base (this);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::internal::lambda_select2, sigc::internal::lambda_select3>; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::internal::lambda_select2, sigc::internal::lambda_select3>&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.93796;

  D.93796 = &this->D.46479;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::internal::lambda_select2, sigc::internal::lambda_select3>, true>::lambda_core (D.93796, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::internal::lambda_select2, sigc::internal::lambda_select3>] (struct lambda_core * const this, const struct lambda_operator & v)
{
  sigc::lambda_base::lambda_base (this);
}


sigc::lambda<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, T_arg1, T_arg2> > sigc::operator+(const sigc::lambda<T_type>&, const sigc::lambda<T_type1>&) [with T_arg1 = sigc::internal::lambda_select1; T_arg2 = sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::internal::lambda_select2, sigc::internal::lambda_select3>] (const struct lambda & a1, const struct lambda & a2)
{
  struct lambda D.93797;
  struct lambda D.84431;
  struct operator_type D.84421;
  const struct lambda_operator * D.93798;
  const struct lambda_select1 * D.93799;
  typedef struct operator_type operator_type;

  D.93798 = &a2->D.46479.value_;
  D.93799 = &a1->D.40074.value_;
  sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::internal::lambda_select2, sigc::internal::lambda_select3> >::lambda_operator (&D.84421, D.93799, D.93798);
  try
    {
      sigc::lambda<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::internal::lambda_select2, sigc::internal::lambda_select3> > >::lambda (&D.84431, &D.84421);
      try
        {
          return D.93797;
        }
      finally
        {
          D.84431 = {CLOBBER};
        }
    }
  finally
    {
      D.84421 = {CLOBBER};
    }
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::arithmetic<sigc::plus>; T_type1 = sigc::internal::lambda_select1; T_type2 = sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::internal::lambda_select2, sigc::internal::lambda_select3>; typename sigc::type_trait<T_derived>::take = const sigc::internal::lambda_select1&; typename sigc::type_trait<T_arg3>::take = const sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::internal::lambda_select2, sigc::internal::lambda_select3>&] (struct lambda_operator * const this, const struct lambda_select1 & a1, const struct lambda_operator & a2)
{
  sigc::lambda_base::lambda_base (this);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::internal::lambda_select2, sigc::internal::lambda_select3> >; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::internal::lambda_select2, sigc::internal::lambda_select3> >&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.93804;

  D.93804 = &this->D.47311;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::internal::lambda_select2, sigc::internal::lambda_select3> >, true>::lambda_core (D.93804, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::internal::lambda_select2, sigc::internal::lambda_select3> >] (struct lambda_core * const this, const struct lambda_operator & v)
{
  sigc::lambda_base::lambda_base (this);
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2, T_arg3) const [with T_arg1 = int; T_arg2 = int; T_arg3 = int; T_type = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::internal::lambda_select2, sigc::internal::lambda_select3> >; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type = int] (const struct lambda_core * const this, int _A_1, int _A_2, int _A_3)
{
  type D.93805;
  const struct lambda_operator * D.93806;

  D.93806 = &this->value_;
  D.93805 = sigc::lambda_operator<sigc::arithmetic<sigc::plus>, sigc::internal::lambda_select1, sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::internal::lambda_select2, sigc::internal::lambda_select3> >::operator()<int&, int&, int&> (D.93806, &_A_1, &_A_2, &_A_3);
  return D.93805;
}


typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()(T_arg1, T_arg2, T_arg3) const [with T_arg1 = int&; T_arg2 = int&; T_arg3 = int&; T_action = sigc::arithmetic<sigc::plus>; T_type1 = sigc::internal::lambda_select1; T_type2 = sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::internal::lambda_select2, sigc::internal::lambda_select3>; typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type = int] (const struct lambda_operator * const this, int & _A_1, int & _A_2, int & _A_3)
{
  type D.93809;
  const struct arg2_type * D.93810;
  int D.93811;
  const struct arg1_type * D.93812;
  int & D.93813;

  D.93810 = &this->arg2_;
  D.93811 = sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::internal::lambda_select2, sigc::internal::lambda_select3>::operator()<int&, int&, int&> (D.93810, _A_1, _A_2, _A_3);
  D.93812 = &this->arg1_;
  D.93813 = sigc::internal::lambda_select1::operator()<int&, int&, int&> (D.93812, _A_1, _A_2, _A_3);
  D.93809 = sigc::lambda_action<sigc::arithmetic<sigc::plus> >::do_action<int&, int> (D.93813, D.93811);
  return D.93809;
}


typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()(T_arg1, T_arg2, T_arg3) const [with T_arg1 = int&; T_arg2 = int&; T_arg3 = int&; T_action = sigc::arithmetic<sigc::multiplies>; T_type1 = sigc::internal::lambda_select2; T_type2 = sigc::internal::lambda_select3; typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type = int] (const struct lambda_operator * const this, int & _A_1, int & _A_2, int & _A_3)
{
  type D.93816;
  const struct arg2_type * D.93817;
  int & D.93818;
  const struct arg1_type * D.93819;
  int & D.93820;

  D.93817 = &this->arg2_;
  D.93818 = sigc::internal::lambda_select3::operator()<int&, int&, int&> (D.93817, _A_1, _A_2, _A_3);
  D.93819 = &this->arg1_;
  D.93820 = sigc::internal::lambda_select2::operator()<int&, int&, int&> (D.93819, _A_1, _A_2, _A_3);
  D.93816 = sigc::lambda_action<sigc::arithmetic<sigc::multiplies> >::do_action<int&, int&> (D.93820, D.93818);
  return D.93816;
}


T_arg3 sigc::internal::lambda_select3::operator()(T_arg1, T_arg2, T_arg3) const [with T_arg1 = int&; T_arg2 = int&; T_arg3 = int&] (const struct lambda_select3 * const this, int & D.91006, int & D.91007, int & _A_3)
{
  int & D.93822;

  D.93822 = _A_3;
  return D.93822;
}


T_arg2 sigc::internal::lambda_select2::operator()(T_arg1, T_arg2, T_arg3) const [with T_arg1 = int&; T_arg2 = int&; T_arg3 = int&] (const struct lambda_select2 * const this, int & D.91001, int & _A_2, int & D.91003)
{
  int & D.93824;

  D.93824 = _A_2;
  return D.93824;
}


static typename sigc::lambda_action_deduce_result_type<sigc::arithmetic<sigc::multiplies>, T_arg1, T_arg2>::type sigc::lambda_action<sigc::arithmetic<sigc::multiplies> >::do_action(T_arg1, T_arg2) [with T_arg1 = int&; T_arg2 = int&; typename sigc::lambda_action_deduce_result_type<sigc::arithmetic<sigc::multiplies>, T_arg1, T_arg2>::type = int] (int & _A_1, int & _A_2)
{
  type D.93826;
  int D.93827;
  int D.93828;

  D.93827 = *_A_1;
  D.93828 = *_A_2;
  D.93826 = D.93827 * D.93828;
  return D.93826;
}


T_arg1 sigc::internal::lambda_select1::operator()(T_arg1, T_arg2, T_arg3) const [with T_arg1 = int&; T_arg2 = int&; T_arg3 = int&] (const struct lambda_select1 * const this, int & _A_1, int & D.87558, int & D.87559)
{
  int & D.93830;

  D.93830 = _A_1;
  return D.93830;
}


sigc::lambda<sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, T_arg> > sigc::operator++(const sigc::lambda<T_type>&) [with T_arg = sigc::internal::lambda_select1] (const struct lambda & a)
{
  struct lambda D.93832;
  struct lambda D.84548;
  struct operator_type D.84538;
  const struct lambda_select1 * D.93833;
  typedef struct operator_type operator_type;

  D.93833 = &a->D.40074.value_;
  sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::internal::lambda_select1>::lambda_operator_unary (&D.84538, D.93833);
  try
    {
      sigc::lambda<sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::internal::lambda_select1> >::lambda (&D.84548, &D.84538);
      try
        {
          return D.93832;
        }
      finally
        {
          D.84548 = {CLOBBER};
        }
    }
  finally
    {
      D.84538 = {CLOBBER};
    }
}


sigc::lambda_operator_unary<T_action, T_type>::lambda_operator_unary(typename sigc::type_trait<T_derived>::take) [with T_action = sigc::unary_arithmetic<sigc::pre_increment>; T_type = sigc::internal::lambda_select1; typename sigc::type_trait<T_derived>::take = const sigc::internal::lambda_select1&] (struct lambda_operator_unary * const this, const struct lambda_select1 & a)
{
  sigc::lambda_base::lambda_base (this);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::internal::lambda_select1>; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::internal::lambda_select1>&] (struct lambda * const this, const struct lambda_operator_unary & v)
{
  struct lambda_core * D.93838;

  D.93838 = &this->D.48206;
  sigc::internal::lambda_core<sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::internal::lambda_select1>, true>::lambda_core (D.93838, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::internal::lambda_select1>] (struct lambda_core * const this, const struct lambda_operator_unary & v)
{
  sigc::lambda_base::lambda_base (this);
}


sigc::lambda<sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, T_arg1, typename sigc::unwrap_reference<T_arg2>::type> > sigc::operator*(const sigc::lambda<T_type>&, const T_arg2&) [with T_arg1 = sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::internal::lambda_select1>; T_arg2 = int; typename sigc::unwrap_reference<T_arg2>::type = int] (const struct lambda & a1, const int & a2)
{
  struct lambda D.93839;
  struct lambda D.84570;
  struct operator_type D.84560;
  const struct lambda_operator_unary * D.93840;
  typedef struct operator_type operator_type;

  D.93840 = &a1->D.48206.value_;
  sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::internal::lambda_select1>, int>::lambda_operator (&D.84560, D.93840, a2);
  try
    {
      sigc::lambda<sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::internal::lambda_select1>, int> >::lambda (&D.84570, &D.84560);
      try
        {
          D.93839 = D.84570;
          return D.93839;
        }
      finally
        {
          D.84570 = {CLOBBER};
        }
    }
  finally
    {
      D.84560 = {CLOBBER};
    }
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::arithmetic<sigc::multiplies>; T_type1 = sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::internal::lambda_select1>; T_type2 = int; typename sigc::type_trait<T_derived>::take = const sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::internal::lambda_select1>&; typename sigc::type_trait<T_arg3>::take = const int&] (struct lambda_operator * const this, const struct lambda_operator_unary & a1, const int & a2)
{
  struct arg2_type * D.93845;

  sigc::lambda_base::lambda_base (this);
  D.93845 = &this->arg2_;
  sigc::lambda<int>::lambda (D.93845, a2);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::internal::lambda_select1>, int>; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::internal::lambda_select1>, int>&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.93846;

  D.93846 = &this->D.49029;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::internal::lambda_select1>, int>, true>::lambda_core (D.93846, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::internal::lambda_select1>, int>] (struct lambda_core * const this, const struct lambda_operator & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1) const [with T_arg1 = int; T_type = sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::internal::lambda_select1>, int>; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1>::type = int] (const struct lambda_core * const this, int _A_1)
{
  type D.93847;
  const struct lambda_operator * D.93848;

  D.93848 = &this->value_;
  D.93847 = sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::internal::lambda_select1>, int>::operator()<int&> (D.93848, &_A_1);
  return D.93847;
}


typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1>::type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()(T_arg1) const [with T_arg1 = int&; T_action = sigc::arithmetic<sigc::multiplies>; T_type1 = sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::internal::lambda_select1>; T_type2 = int; typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1>::type = int] (const struct lambda_operator * const this, int & _A_1)
{
  type D.93851;
  const struct lambda_core * D.93852;
  int D.93853;
  const struct arg1_type * D.93854;
  int D.93855;

  D.93852 = &this->arg2_.D.41753;
  D.93853 = sigc::internal::lambda_core<int, false>::operator()<int&> (D.93852, _A_1);
  D.93854 = &this->arg1_;
  D.93855 = sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::internal::lambda_select1>::operator()<int&> (D.93854, _A_1);
  D.93851 = sigc::lambda_action<sigc::arithmetic<sigc::multiplies> >::do_action<int, int> (D.93855, D.93853);
  return D.93851;
}


sigc::internal::lambda_core<T_type, false>::result_type sigc::internal::lambda_core<T_type, false>::operator()(T_arg1) const [with T_arg1 = int&; T_type = int; sigc::internal::lambda_core<T_type, false>::result_type = int] (const struct lambda_core * const this, int & D.87786)
{
  result_type D.93858;

  D.93858 = this->value_;
  return D.93858;
}


typename sigc::lambda_operator_unary<T_action, T_type>::deduce_result_type<T_arg1>::type sigc::lambda_operator_unary<T_action, T_type>::operator()(T_arg1) const [with T_arg1 = int&; T_action = sigc::unary_arithmetic<sigc::pre_increment>; T_type = sigc::internal::lambda_select1; typename sigc::lambda_operator_unary<T_action, T_type>::deduce_result_type<T_arg1>::type = int] (const struct lambda_operator_unary * const this, int & _A_1)
{
  type D.93860;
  const struct arg_type * D.93861;
  int & D.93862;

  D.93861 = &this->arg_;
  D.93862 = sigc::internal::lambda_select1::operator()<int&> (D.93861, _A_1);
  D.93860 = sigc::lambda_action_unary<sigc::unary_arithmetic<sigc::pre_increment> >::do_action<int&> (D.93862);
  return D.93860;
}


T_arg1 sigc::internal::lambda_select1::operator()(T_arg1) const [with T_arg1 = int&] (const struct lambda_select1 * const this, int & _A_1)
{
  int & D.93864;

  D.93864 = _A_1;
  return D.93864;
}


static typename sigc::lambda_action_unary_deduce_result_type<sigc::unary_arithmetic<sigc::pre_increment>, T_arg>::type sigc::lambda_action_unary<sigc::unary_arithmetic<sigc::pre_increment> >::do_action(T_arg) [with T_arg = int&; typename sigc::lambda_action_unary_deduce_result_type<sigc::unary_arithmetic<sigc::pre_increment>, T_arg>::type = int] (int & _Aa)
{
  type D.93866;
  int D.93867;
  int D.93868;

  D.93867 = *_Aa;
  D.93868 = D.93867 + 1;
  *_Aa = D.93868;
  D.93866 = *_Aa;
  return D.93866;
}


static typename sigc::lambda_action_deduce_result_type<sigc::arithmetic<sigc::multiplies>, T_arg1, T_arg2>::type sigc::lambda_action<sigc::arithmetic<sigc::multiplies> >::do_action(T_arg1, T_arg2) [with T_arg1 = int; T_arg2 = int; typename sigc::lambda_action_deduce_result_type<sigc::arithmetic<sigc::multiplies>, T_arg1, T_arg2>::type = int] (int _A_1, int _A_2)
{
  type D.93870;

  D.93870 = _A_1 * _A_2;
  return D.93870;
}


sigc::lambda<sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, T_arg> > sigc::operator++(const sigc::lambda<T_type>&) [with T_arg = sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1>] (const struct lambda & a)
{
  struct lambda D.93872;
  struct lambda D.84724;
  struct operator_type D.84714;
  const struct lambda_operator_unary * D.93873;
  typedef struct operator_type operator_type;

  D.93873 = &a->D.49945.value_;
  sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >::lambda_operator_unary (&D.84714, D.93873);
  try
    {
      sigc::lambda<sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> > >::lambda (&D.84724, &D.84714);
      try
        {
          return D.93872;
        }
      finally
        {
          D.84724 = {CLOBBER};
        }
    }
  finally
    {
      D.84714 = {CLOBBER};
    }
}


sigc::lambda_operator_unary<T_action, T_type>::lambda_operator_unary(typename sigc::type_trait<T_derived>::take) [with T_action = sigc::unary_arithmetic<sigc::pre_increment>; T_type = sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1>; typename sigc::type_trait<T_derived>::take = const sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1>&] (struct lambda_operator_unary * const this, const struct lambda_operator_unary & a)
{
  sigc::lambda_base::lambda_base (this);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >&] (struct lambda * const this, const struct lambda_operator_unary & v)
{
  struct lambda_core * D.93878;

  D.93878 = &this->D.50756;
  sigc::internal::lambda_core<sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >, true>::lambda_core (D.93878, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >] (struct lambda_core * const this, const struct lambda_operator_unary & v)
{
  sigc::lambda_base::lambda_base (this);
}


sigc::lambda<sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, T_arg1, typename sigc::unwrap_reference<T_arg2>::type> > sigc::operator*(const sigc::lambda<T_type>&, const T_arg2&) [with T_arg1 = sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >; T_arg2 = int; typename sigc::unwrap_reference<T_arg2>::type = int] (const struct lambda & a1, const int & a2)
{
  struct lambda D.93879;
  struct lambda D.84746;
  struct operator_type D.84736;
  const struct lambda_operator_unary * D.93880;
  typedef struct operator_type operator_type;

  D.93880 = &a1->D.50756.value_;
  sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >, int>::lambda_operator (&D.84736, D.93880, a2);
  try
    {
      sigc::lambda<sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >, int> >::lambda (&D.84746, &D.84736);
      try
        {
          D.93879 = D.84746;
          return D.93879;
        }
      finally
        {
          D.84746 = {CLOBBER};
        }
    }
  finally
    {
      D.84736 = {CLOBBER};
    }
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::arithmetic<sigc::multiplies>; T_type1 = sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >; T_type2 = int; typename sigc::type_trait<T_derived>::take = const sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >&; typename sigc::type_trait<T_arg3>::take = const int&] (struct lambda_operator * const this, const struct lambda_operator_unary & a1, const int & a2)
{
  struct arg2_type * D.93885;

  sigc::lambda_base::lambda_base (this);
  D.93885 = &this->arg2_;
  sigc::lambda<int>::lambda (D.93885, a2);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >, int>; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >, int>&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.93886;

  D.93886 = &this->D.51573;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >, int>, true>::lambda_core (D.93886, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >, int>] (struct lambda_core * const this, const struct lambda_operator & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1) const [with T_arg1 = int*; T_type = sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >, int>; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1>::type = int] (const struct lambda_core * const this, int * _A_1)
{
  type D.93887;
  const struct lambda_operator * D.93888;

  D.93888 = &this->value_;
  D.93887 = sigc::lambda_operator<sigc::arithmetic<sigc::multiplies>, sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >, int>::operator()<int*&> (D.93888, &_A_1);
  return D.93887;
}


typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1>::type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()(T_arg1) const [with T_arg1 = int*&; T_action = sigc::arithmetic<sigc::multiplies>; T_type1 = sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >; T_type2 = int; typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1>::type = int] (const struct lambda_operator * const this, int * & _A_1)
{
  type D.93891;
  const struct lambda_core * D.93892;
  int D.93893;
  const struct arg1_type * D.93894;
  int D.93895;

  D.93892 = &this->arg2_.D.41753;
  D.93893 = sigc::internal::lambda_core<int, false>::operator()<int*&> (D.93892, _A_1);
  D.93894 = &this->arg1_;
  D.93895 = sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::pre_increment>, sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >::operator()<int*&> (D.93894, _A_1);
  D.93891 = sigc::lambda_action<sigc::arithmetic<sigc::multiplies> >::do_action<int, int> (D.93895, D.93893);
  return D.93891;
}


sigc::internal::lambda_core<T_type, false>::result_type sigc::internal::lambda_core<T_type, false>::operator()(T_arg1) const [with T_arg1 = int*&; T_type = int; sigc::internal::lambda_core<T_type, false>::result_type = int] (const struct lambda_core * const this, int * & D.87956)
{
  result_type D.93898;

  D.93898 = this->value_;
  return D.93898;
}


typename sigc::lambda_operator_unary<T_action, T_type>::deduce_result_type<T_arg1>::type sigc::lambda_operator_unary<T_action, T_type>::operator()(T_arg1) const [with T_arg1 = int*&; T_action = sigc::unary_arithmetic<sigc::pre_increment>; T_type = sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1>; typename sigc::lambda_operator_unary<T_action, T_type>::deduce_result_type<T_arg1>::type = int] (const struct lambda_operator_unary * const this, int * & _A_1)
{
  type D.93900;
  const struct arg_type * D.93901;
  int & D.93902;

  D.93901 = &this->arg_;
  D.93902 = sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1>::operator()<int*&> (D.93901, _A_1);
  D.93900 = sigc::lambda_action_unary<sigc::unary_arithmetic<sigc::pre_increment> >::do_action<int&> (D.93902);
  return D.93900;
}


typename sigc::lambda_operator_unary<T_action, T_type>::deduce_result_type<T_arg1>::type sigc::lambda_operator_unary<T_action, T_type>::operator()(T_arg1) const [with T_arg1 = int*&; T_action = sigc::unary_other<sigc::dereference>; T_type = sigc::internal::lambda_select1; typename sigc::lambda_operator_unary<T_action, T_type>::deduce_result_type<T_arg1>::type = int&] (const struct lambda_operator_unary * const this, int * & _A_1)
{
  int & D.93905;
  const struct arg_type * D.93906;
  int * & D.93907;

  D.93906 = &this->arg_;
  D.93907 = sigc::internal::lambda_select1::operator()<int*&> (D.93906, _A_1);
  D.93905 = sigc::lambda_action_unary<sigc::unary_other<sigc::dereference> >::do_action<int*&> (D.93907);
  return D.93905;
}


T_arg1 sigc::internal::lambda_select1::operator()(T_arg1) const [with T_arg1 = int*&] (const struct lambda_select1 * const this, int * & _A_1)
{
  int * & D.93909;

  D.93909 = _A_1;
  return D.93909;
}


static typename sigc::lambda_action_unary_deduce_result_type<sigc::unary_other<sigc::dereference>, T_test>::type sigc::lambda_action_unary<sigc::unary_other<sigc::dereference> >::do_action(T_arg) [with T_arg = int*&; typename sigc::lambda_action_unary_deduce_result_type<sigc::unary_other<sigc::dereference>, T_test>::type = int&] (int * & _Aa)
{
  int & D.93911;

  D.93911 = *_Aa;
  return D.93911;
}


sigc::lambda<sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::negate>, T_arg> > sigc::operator-(const sigc::lambda<T_type>&) [with T_arg = sigc::internal::lambda_select1] (const struct lambda & a)
{
  struct lambda D.93913;
  struct lambda D.84887;
  struct operator_type D.84877;
  const struct lambda_select1 * D.93914;
  typedef struct operator_type operator_type;

  D.93914 = &a->D.40074.value_;
  sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::negate>, sigc::internal::lambda_select1>::lambda_operator_unary (&D.84877, D.93914);
  try
    {
      sigc::lambda<sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::negate>, sigc::internal::lambda_select1> >::lambda (&D.84887, &D.84877);
      try
        {
          return D.93913;
        }
      finally
        {
          D.84887 = {CLOBBER};
        }
    }
  finally
    {
      D.84877 = {CLOBBER};
    }
}


sigc::lambda_operator_unary<T_action, T_type>::lambda_operator_unary(typename sigc::type_trait<T_derived>::take) [with T_action = sigc::unary_arithmetic<sigc::negate>; T_type = sigc::internal::lambda_select1; typename sigc::type_trait<T_derived>::take = const sigc::internal::lambda_select1&] (struct lambda_operator_unary * const this, const struct lambda_select1 & a)
{
  sigc::lambda_base::lambda_base (this);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::negate>, sigc::internal::lambda_select1>; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::negate>, sigc::internal::lambda_select1>&] (struct lambda * const this, const struct lambda_operator_unary & v)
{
  struct lambda_core * D.93919;

  D.93919 = &this->D.52512;
  sigc::internal::lambda_core<sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::negate>, sigc::internal::lambda_select1>, true>::lambda_core (D.93919, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::negate>, sigc::internal::lambda_select1>] (struct lambda_core * const this, const struct lambda_operator_unary & v)
{
  sigc::lambda_base::lambda_base (this);
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1) const [with T_arg1 = int; T_type = sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::negate>, sigc::internal::lambda_select1>; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1>::type = int] (const struct lambda_core * const this, int _A_1)
{
  type D.93920;
  const struct lambda_operator_unary * D.93921;

  D.93921 = &this->value_;
  D.93920 = sigc::lambda_operator_unary<sigc::unary_arithmetic<sigc::negate>, sigc::internal::lambda_select1>::operator()<int&> (D.93921, &_A_1);
  return D.93920;
}


typename sigc::lambda_operator_unary<T_action, T_type>::deduce_result_type<T_arg1>::type sigc::lambda_operator_unary<T_action, T_type>::operator()(T_arg1) const [with T_arg1 = int&; T_action = sigc::unary_arithmetic<sigc::negate>; T_type = sigc::internal::lambda_select1; typename sigc::lambda_operator_unary<T_action, T_type>::deduce_result_type<T_arg1>::type = int] (const struct lambda_operator_unary * const this, int & _A_1)
{
  type D.93924;
  const struct arg_type * D.93925;
  int & D.93926;

  D.93925 = &this->arg_;
  D.93926 = sigc::internal::lambda_select1::operator()<int&> (D.93925, _A_1);
  D.93924 = sigc::lambda_action_unary<sigc::unary_arithmetic<sigc::negate> >::do_action<int&> (D.93926);
  return D.93924;
}


static typename sigc::lambda_action_unary_deduce_result_type<sigc::unary_arithmetic<sigc::negate>, T_arg>::type sigc::lambda_action_unary<sigc::unary_arithmetic<sigc::negate> >::do_action(T_arg) [with T_arg = int&; typename sigc::lambda_action_unary_deduce_result_type<sigc::unary_arithmetic<sigc::negate>, T_arg>::type = int] (int & _Aa)
{
  type D.93928;
  int D.93929;

  D.93929 = *_Aa;
  D.93928 = -D.93929;
  return D.93928;
}


sigc::lambda<const T_type&> sigc::var(const T_type&) [with T_type = int*] (int * const & v)
{
  struct lambda D.93931;
  struct lambda D.85017;

  sigc::lambda<int* const&>::lambda (&D.85017, v);
  try
    {
      D.93931 = D.85017;
      return D.93931;
    }
  finally
    {
      D.85017 = {CLOBBER};
    }
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = int* const&; typename sigc::type_trait<T_base>::take = int* const&] (struct lambda * const this, int * const & v)
{
  struct lambda_core * D.93934;

  D.93934 = &this->D.52879;
  sigc::internal::lambda_core<int* const&, false>::lambda_core (D.93934, v);
}


sigc::internal::lambda_core<T_type, false>::lambda_core(typename sigc::type_trait<T_base>::take) [with T_type = int* const&; typename sigc::type_trait<T_base>::take = int* const&] (struct lambda_core * const this, int * const & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = v;
}


sigc::lambda<sigc::lambda_operator<sigc::other<sigc::subscript>, sigc::lambda<T_type>, typename sigc::unwrap_lambda_type<T_arg>::type> > sigc::lambda<T_type>::operator[](const T_arg&) const [with T_arg = int; T_type = int* const&; typename sigc::unwrap_lambda_type<T_arg>::type = int] (const struct lambda * const this, const int & a)
{
  struct lambda_operator_type D.85034;
  const int & D.93936;
  const struct lambda D.85033;
  int * const & D.93937;
  typedef struct lambda_operator_type lambda_operator_type;

  D.93936 = sigc::unwrap_lambda_value<int> (a);
  D.93937 = this->D.52879.value_;
  sigc::lambda<int* const&>::lambda (&D.85033, D.93937);
  try
    {
      sigc::lambda_operator<sigc::other<sigc::subscript>, sigc::lambda<int* const&>, int>::lambda_operator (&D.85034, &D.85033, D.93936);
      try
        {
          sigc::lambda<sigc::lambda_operator<sigc::other<sigc::subscript>, sigc::lambda<int* const&>, int> >::lambda (&<retval>, &D.85034);
          return <retval>;
        }
      finally
        {
          D.85034 = {CLOBBER};
        }
    }
  finally
    {
      D.85033 = {CLOBBER};
    }
}


const T_type& sigc::unwrap_lambda_value(const T_type&) [with T_type = int] (const int & a)
{
  const int & D.93943;

  D.93943 = a;
  return D.93943;
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::other<sigc::subscript>; T_type1 = sigc::lambda<int* const&>; T_type2 = int; typename sigc::type_trait<T_derived>::take = const sigc::lambda<int* const&>&; typename sigc::type_trait<T_arg3>::take = const int&] (struct lambda_operator * const this, const struct lambda & a1, const int & a2)
{
  struct arg2_type * D.93945;

  sigc::lambda_base::lambda_base (this);
  this->arg1_ = *a1;
  D.93945 = &this->arg2_;
  sigc::lambda<int>::lambda (D.93945, a2);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::other<sigc::subscript>, sigc::lambda<int* const&>, int>; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::other<sigc::subscript>, sigc::lambda<int* const&>, int>&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.93946;

  D.93946 = &this->D.54173;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::other<sigc::subscript>, sigc::lambda<int* const&>, int>, true>::lambda_core (D.93946, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::other<sigc::subscript>, sigc::lambda<int* const&>, int>] (struct lambda_core * const this, const struct lambda_operator & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


sigc::internal::lambda_core<T_type, true>::result_type sigc::internal::lambda_core<T_type, true>::operator()() const [with T_type = sigc::lambda_operator<sigc::other<sigc::subscript>, sigc::lambda<int* const&>, int>; sigc::internal::lambda_core<T_type, true>::result_type = int&] (const struct lambda_core * const this)
{
  int & D.93947;
  const struct lambda_operator * D.93948;

  D.93948 = &this->value_;
  D.93947 = sigc::lambda_operator<sigc::other<sigc::subscript>, sigc::lambda<int* const&>, int>::operator() (D.93948);
  return D.93947;
}


sigc::lambda_operator<T_action, T_type1, T_type2>::result_type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()() const [with T_action = sigc::other<sigc::subscript>; T_type1 = sigc::lambda<int* const&>; T_type2 = int; sigc::lambda_operator<T_action, T_type1, T_type2>::result_type = int&] (const struct lambda_operator * const this)
{
  int & D.93951;
  const struct lambda_core * D.93952;
  int D.93953;
  const struct lambda_core * D.93954;
  int * const & D.93955;

  D.93952 = &this->arg2_.D.41753;
  D.93953 = sigc::internal::lambda_core<int, false>::operator() (D.93952);
  D.93954 = &this->arg1_.D.52879;
  D.93955 = sigc::internal::lambda_core<int* const&, false>::operator() (D.93954);
  D.93951 = sigc::lambda_action<sigc::other<sigc::subscript> >::do_action<int* const&, int> (D.93955, D.93953);
  return D.93951;
}


sigc::internal::lambda_core<T_type, false>::result_type sigc::internal::lambda_core<T_type, false>::operator()() const [with T_type = int; sigc::internal::lambda_core<T_type, false>::result_type = int] (const struct lambda_core * const this)
{
  result_type D.93957;

  D.93957 = this->value_;
  return D.93957;
}


sigc::internal::lambda_core<T_type, false>::result_type sigc::internal::lambda_core<T_type, false>::operator()() const [with T_type = int* const&; sigc::internal::lambda_core<T_type, false>::result_type = int* const&] (const struct lambda_core * const this)
{
  int * const & D.93959;

  D.93959 = this->value_;
  return D.93959;
}


static typename sigc::lambda_action_deduce_result_type<sigc::other<sigc::subscript>, T_test1, T_test2>::type sigc::lambda_action<sigc::other<sigc::subscript> >::do_action(T_arg1, T_arg2) [with T_arg1 = int* const&; T_arg2 = int; typename sigc::lambda_action_deduce_result_type<sigc::other<sigc::subscript>, T_test1, T_test2>::type = int&] (int * const & _A_1, int _A_2)
{
  int & D.93961;
  int * D.93962;
  long unsigned int D.93963;
  long unsigned int D.93964;

  D.93962 = *_A_1;
  D.93963 = (long unsigned int) _A_2;
  D.93964 = D.93963 * 4;
  D.93961 = D.93962 + D.93964;
  return D.93961;
}


sigc::lambda<sigc::lambda_operator<sigc::other<sigc::subscript>, sigc::lambda<T_type>, typename sigc::unwrap_lambda_type<T_arg>::type> > sigc::lambda<T_type>::operator[](const T_arg&) const [with T_arg = sigc::lambda<sigc::internal::lambda_select2>; T_type = sigc::internal::lambda_select1; typename sigc::unwrap_lambda_type<T_arg>::type = sigc::internal::lambda_select2] (const struct lambda * const this, const struct lambda & a)
{
  struct lambda D.93966;
  struct lambda D.85081;
  struct lambda_operator_type D.85071;
  const struct lambda_select2 & D.93967;
  const struct lambda D.85070;
  const struct lambda_select1 * D.93968;
  typedef struct lambda_operator_type lambda_operator_type;

  D.93967 = sigc::unwrap_lambda_value<sigc::internal::lambda_select2> (a);
  D.93968 = &this->D.40074.value_;
  sigc::lambda<sigc::internal::lambda_select1>::lambda (&D.85070, D.93968);
  try
    {
      sigc::lambda_operator<sigc::other<sigc::subscript>, sigc::lambda<sigc::internal::lambda_select1>, sigc::internal::lambda_select2>::lambda_operator (&D.85071, &D.85070, D.93967);
      try
        {
          sigc::lambda<sigc::lambda_operator<sigc::other<sigc::subscript>, sigc::lambda<sigc::internal::lambda_select1>, sigc::internal::lambda_select2> >::lambda (&D.85081, &D.85071);
          try
            {
              return D.93966;
            }
          finally
            {
              D.85081 = {CLOBBER};
            }
        }
      finally
        {
          D.85071 = {CLOBBER};
        }
    }
  finally
    {
      D.85070 = {CLOBBER};
    }
}


const T_type& sigc::unwrap_lambda_value(const sigc::lambda<T_type>&) [with T_type = sigc::internal::lambda_select2] (const struct lambda & a)
{
  const struct lambda_select2 & D.93975;

  D.93975 = &a->D.40511.value_;
  return D.93975;
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::internal::lambda_select1; typename sigc::type_trait<T_base>::take = const sigc::internal::lambda_select1&] (struct lambda * const this, const struct lambda_select1 & v)
{
  struct lambda_core * D.93977;

  D.93977 = &this->D.40074;
  sigc::internal::lambda_core<sigc::internal::lambda_select1, true>::lambda_core (D.93977, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::internal::lambda_select1] (struct lambda_core * const this, const struct lambda_select1 & v)
{
  sigc::lambda_base::lambda_base (this);
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::other<sigc::subscript>; T_type1 = sigc::lambda<sigc::internal::lambda_select1>; T_type2 = sigc::internal::lambda_select2; typename sigc::type_trait<T_derived>::take = const sigc::lambda<sigc::internal::lambda_select1>&; typename sigc::type_trait<T_arg3>::take = const sigc::internal::lambda_select2&] (struct lambda_operator * const this, const struct lambda & a1, const struct lambda_select2 & a2)
{
  sigc::lambda_base::lambda_base (this);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::other<sigc::subscript>, sigc::lambda<sigc::internal::lambda_select1>, sigc::internal::lambda_select2>; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::other<sigc::subscript>, sigc::lambda<sigc::internal::lambda_select1>, sigc::internal::lambda_select2>&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.93978;

  D.93978 = &this->D.55438;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::other<sigc::subscript>, sigc::lambda<sigc::internal::lambda_select1>, sigc::internal::lambda_select2>, true>::lambda_core (D.93978, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::other<sigc::subscript>, sigc::lambda<sigc::internal::lambda_select1>, sigc::internal::lambda_select2>] (struct lambda_core * const this, const struct lambda_operator & v)
{
  sigc::lambda_base::lambda_base (this);
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2) const [with T_arg1 = int*; T_arg2 = int; T_type = sigc::lambda_operator<sigc::other<sigc::subscript>, sigc::lambda<sigc::internal::lambda_select1>, sigc::internal::lambda_select2>; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type = int&] (const struct lambda_core * const this, int * _A_1, int _A_2)
{
  int & D.93979;
  const struct lambda_operator * D.93980;

  D.93980 = &this->value_;
  D.93979 = sigc::lambda_operator<sigc::other<sigc::subscript>, sigc::lambda<sigc::internal::lambda_select1>, sigc::internal::lambda_select2>::operator()<int*&, int&> (D.93980, &_A_1, &_A_2);
  return D.93979;
}


typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()(T_arg1, T_arg2) const [with T_arg1 = int*&; T_arg2 = int&; T_action = sigc::other<sigc::subscript>; T_type1 = sigc::lambda<sigc::internal::lambda_select1>; T_type2 = sigc::internal::lambda_select2; typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type = int&] (const struct lambda_operator * const this, int * & _A_1, int & _A_2)
{
  int & D.93983;
  const struct arg2_type * D.93984;
  int & D.93985;
  const struct lambda_core * D.93986;
  int * & D.93987;

  D.93984 = &this->arg2_;
  D.93985 = sigc::internal::lambda_select2::operator()<int*&, int&> (D.93984, _A_1, _A_2);
  D.93986 = &this->arg1_.D.40074;
  D.93987 = sigc::internal::lambda_core<sigc::internal::lambda_select1, true>::operator()<int*&, int&> (D.93986, _A_1, _A_2);
  D.93983 = sigc::lambda_action<sigc::other<sigc::subscript> >::do_action<int*&, int&> (D.93987, D.93985);
  return D.93983;
}


T_arg2 sigc::internal::lambda_select2::operator()(T_arg1, T_arg2) const [with T_arg1 = int*&; T_arg2 = int&] (const struct lambda_select2 * const this, int * & D.88163, int & _A_2)
{
  int & D.93990;

  D.93990 = _A_2;
  return D.93990;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2) const [with T_arg1 = int*&; T_arg2 = int&; T_type = sigc::internal::lambda_select1; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type = int*&] (const struct lambda_core * const this, int * & _A_1, int & _A_2)
{
  int * & D.93992;
  const struct lambda_select1 * D.93993;

  D.93993 = &this->value_;
  D.93992 = sigc::internal::lambda_select1::operator()<int*&, int&> (D.93993, _A_1, _A_2);
  return D.93992;
}


T_arg1 sigc::internal::lambda_select1::operator()(T_arg1, T_arg2) const [with T_arg1 = int*&; T_arg2 = int&] (const struct lambda_select1 * const this, int * & _A_1, int & D.91224)
{
  int * & D.93995;

  D.93995 = _A_1;
  return D.93995;
}


static typename sigc::lambda_action_deduce_result_type<sigc::other<sigc::subscript>, T_test1, T_test2>::type sigc::lambda_action<sigc::other<sigc::subscript> >::do_action(T_arg1, T_arg2) [with T_arg1 = int*&; T_arg2 = int&; typename sigc::lambda_action_deduce_result_type<sigc::other<sigc::subscript>, T_test1, T_test2>::type = int&] (int * & _A_1, int & _A_2)
{
  int & D.93997;
  int * D.93998;
  int D.93999;
  long unsigned int D.94000;
  long unsigned int D.94001;

  D.93998 = *_A_1;
  D.93999 = *_A_2;
  D.94000 = (long unsigned int) D.93999;
  D.94001 = D.94000 * 4;
  D.93997 = D.93998 + D.94001;
  return D.93997;
}


sigc::lambda<sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, T_arg> > sigc::operator*(const sigc::lambda<T_type>&) [with T_arg = sigc::internal::lambda_select1] (const struct lambda & a)
{
  struct lambda D.94003;
  struct lambda D.84702;
  struct operator_type D.84701;
  const struct lambda_select1 * D.94004;
  typedef struct operator_type operator_type;

  D.94004 = &a->D.40074.value_;
  sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1>::lambda_operator_unary (&D.84701, D.94004);
  try
    {
      sigc::lambda<sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >::lambda (&D.84702, &D.84701);
      try
        {
          return D.94003;
        }
      finally
        {
          D.84702 = {CLOBBER};
        }
    }
  finally
    {
      D.84701 = {CLOBBER};
    }
}


sigc::lambda_operator_unary<T_action, T_type>::lambda_operator_unary(typename sigc::type_trait<T_derived>::take) [with T_action = sigc::unary_other<sigc::dereference>; T_type = sigc::internal::lambda_select1; typename sigc::type_trait<T_derived>::take = const sigc::internal::lambda_select1&] (struct lambda_operator_unary * const this, const struct lambda_select1 & a)
{
  sigc::lambda_base::lambda_base (this);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1>; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1>&] (struct lambda * const this, const struct lambda_operator_unary & v)
{
  struct lambda_core * D.94009;

  D.94009 = &this->D.49945;
  sigc::internal::lambda_core<sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1>, true>::lambda_core (D.94009, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1>] (struct lambda_core * const this, const struct lambda_operator_unary & v)
{
  sigc::lambda_base::lambda_base (this);
}


sigc::lambda<sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<T_type>, typename sigc::unwrap_lambda_type<T_arg>::type> > sigc::lambda<T_type>::operator=(const T_arg&) const [with T_arg = sigc::lambda<sigc::internal::lambda_select2>; T_type = sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1>; typename sigc::unwrap_lambda_type<T_arg>::type = sigc::internal::lambda_select2] (const struct lambda * const this, const struct lambda & a)
{
  struct lambda D.94010;
  struct lambda D.85216;
  struct lambda_operator_type D.85206;
  const struct lambda_select2 & D.94011;
  const struct lambda D.85205;
  const struct lambda_operator_unary * D.94012;
  typedef struct lambda_operator_type lambda_operator_type;

  D.94011 = sigc::unwrap_lambda_value<sigc::internal::lambda_select2> (a);
  D.94012 = &this->D.49945.value_;
  sigc::lambda<sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >::lambda (&D.85205, D.94012);
  try
    {
      sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >, sigc::internal::lambda_select2>::lambda_operator (&D.85206, &D.85205, D.94011);
      try
        {
          sigc::lambda<sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >, sigc::internal::lambda_select2> >::lambda (&D.85216, &D.85206);
          try
            {
              return D.94010;
            }
          finally
            {
              D.85216 = {CLOBBER};
            }
        }
      finally
        {
          D.85206 = {CLOBBER};
        }
    }
  finally
    {
      D.85205 = {CLOBBER};
    }
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::other<sigc::assign>; T_type1 = sigc::lambda<sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >; T_type2 = sigc::internal::lambda_select2; typename sigc::type_trait<T_derived>::take = const sigc::lambda<sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >&; typename sigc::type_trait<T_arg3>::take = const sigc::internal::lambda_select2&] (struct lambda_operator * const this, const struct lambda & a1, const struct lambda_select2 & a2)
{
  sigc::lambda_base::lambda_base (this);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >, sigc::internal::lambda_select2>; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >, sigc::internal::lambda_select2>&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.94019;

  D.94019 = &this->D.56784;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >, sigc::internal::lambda_select2>, true>::lambda_core (D.94019, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >, sigc::internal::lambda_select2>] (struct lambda_core * const this, const struct lambda_operator & v)
{
  sigc::lambda_base::lambda_base (this);
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2) const [with T_arg1 = int*; T_arg2 = int; T_type = sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >, sigc::internal::lambda_select2>; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct lambda_core * const this, int * _A_1, int _A_2)
{
  type D.94020;
  const struct lambda_operator * D.94021;

  D.94021 = &this->value_;
  D.94020 = sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >, sigc::internal::lambda_select2>::operator()<int*&, int&> (D.94021, &_A_1, &_A_2);
  return D.94020;
}


typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()(T_arg1, T_arg2) const [with T_arg1 = int*&; T_arg2 = int&; T_action = sigc::other<sigc::assign>; T_type1 = sigc::lambda<sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1> >; T_type2 = sigc::internal::lambda_select2; typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct lambda_operator * const this, int * & _A_1, int & _A_2)
{
  type D.94024;
  const struct arg2_type * D.94025;
  int & D.94026;
  const struct lambda_core * D.94027;
  int & D.94028;

  D.94025 = &this->arg2_;
  D.94026 = sigc::internal::lambda_select2::operator()<int*&, int&> (D.94025, _A_1, _A_2);
  D.94027 = &this->arg1_.D.49945;
  D.94028 = sigc::internal::lambda_core<sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1>, true>::operator()<int*&, int&> (D.94027, _A_1, _A_2);
  D.94024 = sigc::lambda_action<sigc::other<sigc::assign> >::do_action<int&, int&> (D.94028, D.94026);
  return D.94024;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2) const [with T_arg1 = int*&; T_arg2 = int&; T_type = sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1>; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type = int&] (const struct lambda_core * const this, int * & _A_1, int & _A_2)
{
  int & D.94031;
  const struct lambda_operator_unary * D.94032;

  D.94032 = &this->value_;
  D.94031 = sigc::lambda_operator_unary<sigc::unary_other<sigc::dereference>, sigc::internal::lambda_select1>::operator()<int*&, int&> (D.94032, _A_1, _A_2);
  return D.94031;
}


typename sigc::lambda_operator_unary<T_action, T_type>::deduce_result_type<T_arg1, T_arg2>::type sigc::lambda_operator_unary<T_action, T_type>::operator()(T_arg1, T_arg2) const [with T_arg1 = int*&; T_arg2 = int&; T_action = sigc::unary_other<sigc::dereference>; T_type = sigc::internal::lambda_select1; typename sigc::lambda_operator_unary<T_action, T_type>::deduce_result_type<T_arg1, T_arg2>::type = int&] (const struct lambda_operator_unary * const this, int * & _A_1, int & _A_2)
{
  int & D.94035;
  const struct arg_type * D.94036;
  int * & D.94037;

  D.94036 = &this->arg_;
  D.94037 = sigc::internal::lambda_select1::operator()<int*&, int&> (D.94036, _A_1, _A_2);
  D.94035 = sigc::lambda_action_unary<sigc::unary_other<sigc::dereference> >::do_action<int*&> (D.94037);
  return D.94035;
}


static typename sigc::lambda_action_deduce_result_type<sigc::other<sigc::assign>, T_arg1, T_arg2>::type sigc::lambda_action<sigc::other<sigc::assign> >::do_action(T_arg1, T_arg2) [with T_arg1 = int&; T_arg2 = int&; typename sigc::lambda_action_deduce_result_type<sigc::other<sigc::assign>, T_arg1, T_arg2>::type = int] (int & _A_1, int & _A_2)
{
  type D.94039;
  int D.94040;

  D.94040 = *_A_2;
  *_A_1 = D.94040;
  D.94039 = *_A_1;
  return D.94039;
}


sigc::lambda<sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<T_type>, typename sigc::unwrap_lambda_type<T_arg>::type> > sigc::lambda<T_type>::operator=(const T_arg&) const [with T_arg = sigc::lambda<sigc::internal::lambda_select2>; T_type = int&; typename sigc::unwrap_lambda_type<T_arg>::type = sigc::internal::lambda_select2] (const struct lambda * const this, const struct lambda & a)
{
  struct lambda_operator_type D.85377;
  const struct lambda_select2 & D.94043;
  const struct lambda D.85376;
  int & D.94044;
  typedef struct lambda_operator_type lambda_operator_type;

  D.94043 = sigc::unwrap_lambda_value<sigc::internal::lambda_select2> (a);
  D.94044 = this->D.57181.value_;
  sigc::lambda<int&>::lambda (&D.85376, D.94044);
  try
    {
      sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2>::lambda_operator (&D.85377, &D.85376, D.94043);
      try
        {
          sigc::lambda<sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> >::lambda (&<retval>, &D.85377);
          return <retval>;
        }
      finally
        {
          D.85377 = {CLOBBER};
        }
    }
  finally
    {
      D.85376 = {CLOBBER};
    }
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = int&; typename sigc::type_trait<T_base>::take = int&] (struct lambda * const this, int & v)
{
  struct lambda_core * D.94050;

  D.94050 = &this->D.57181;
  sigc::internal::lambda_core<int&, false>::lambda_core (D.94050, v);
}


sigc::internal::lambda_core<T_type, false>::lambda_core(typename sigc::type_trait<T_base>::take) [with T_type = int&; typename sigc::type_trait<T_base>::take = int&] (struct lambda_core * const this, int & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = v;
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::other<sigc::assign>; T_type1 = sigc::lambda<int&>; T_type2 = sigc::internal::lambda_select2; typename sigc::type_trait<T_derived>::take = const sigc::lambda<int&>&; typename sigc::type_trait<T_arg3>::take = const sigc::internal::lambda_select2&] (struct lambda_operator * const this, const struct lambda & a1, const struct lambda_select2 & a2)
{
  sigc::lambda_base::lambda_base (this);
  this->arg1_ = *a1;
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2>; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2>&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.94051;

  D.94051 = &this->D.59294;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2>, true>::lambda_core (D.94051, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2>] (struct lambda_core * const this, const struct lambda_operator & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


sigc::lambda<sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<T_type>, typename sigc::unwrap_lambda_type<T_arg>::type> > sigc::lambda<T_type>::operator=(const T_arg&) const [with T_arg = sigc::lambda<sigc::internal::lambda_select1>; T_type = int&; typename sigc::unwrap_lambda_type<T_arg>::type = sigc::internal::lambda_select1] (const struct lambda * const this, const struct lambda & a)
{
  struct lambda_operator_type D.85349;
  const struct lambda_select1 & D.94053;
  const struct lambda D.85348;
  int & D.94054;
  typedef struct lambda_operator_type lambda_operator_type;

  D.94053 = sigc::unwrap_lambda_value<sigc::internal::lambda_select1> (a);
  D.94054 = this->D.57181.value_;
  sigc::lambda<int&>::lambda (&D.85348, D.94054);
  try
    {
      sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>::lambda_operator (&D.85349, &D.85348, D.94053);
      try
        {
          sigc::lambda<sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1> >::lambda (&<retval>, &D.85349);
          return <retval>;
        }
      finally
        {
          D.85349 = {CLOBBER};
        }
    }
  finally
    {
      D.85348 = {CLOBBER};
    }
}


const T_type& sigc::unwrap_lambda_value(const sigc::lambda<T_type>&) [with T_type = sigc::internal::lambda_select1] (const struct lambda & a)
{
  const struct lambda_select1 & D.94060;

  D.94060 = &a->D.40074.value_;
  return D.94060;
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::other<sigc::assign>; T_type1 = sigc::lambda<int&>; T_type2 = sigc::internal::lambda_select1; typename sigc::type_trait<T_derived>::take = const sigc::lambda<int&>&; typename sigc::type_trait<T_arg3>::take = const sigc::internal::lambda_select1&] (struct lambda_operator * const this, const struct lambda & a1, const struct lambda_select1 & a2)
{
  sigc::lambda_base::lambda_base (this);
  this->arg1_ = *a1;
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.94062;

  D.94062 = &this->D.58471;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, true>::lambda_core (D.94062, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>] (struct lambda_core * const this, const struct lambda_operator & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


sigc::lambda<sigc::lambda_operator<sigc::comma, T_arg1, T_arg2> > sigc::operator,(const sigc::lambda<T_type>&, const sigc::lambda<T_type1>&) [with T_arg1 = sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>; T_arg2 = sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2>] (const struct lambda & a1, const struct lambda & a2)
{
  struct operator_type D.85402;
  const struct lambda_operator * D.94064;
  const struct lambda_operator * D.94065;
  typedef struct operator_type operator_type;

  D.94064 = &a2->D.59294.value_;
  D.94065 = &a1->D.58471.value_;
  sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> >::lambda_operator (&D.85402, D.94065, D.94064);
  try
    {
      sigc::lambda<sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> > >::lambda (&<retval>, &D.85402);
      return <retval>;
    }
  finally
    {
      D.85402 = {CLOBBER};
    }
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::comma; T_type1 = sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>; T_type2 = sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2>; typename sigc::type_trait<T_derived>::take = const sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>&; typename sigc::type_trait<T_arg3>::take = const sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2>&] (struct lambda_operator * const this, const struct lambda_operator & a1, const struct lambda_operator & a2)
{
  sigc::lambda_base::lambda_base (this);
  this->arg1_ = *a1;
  this->arg2_ = *a2;
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> >; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> >&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.94069;

  D.94069 = &this->D.60119;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> >, true>::lambda_core (D.94069, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> >] (struct lambda_core * const this, const struct lambda_operator & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


sigc::lambda<T_type&> sigc::var(T_type&) [with T_type = int] (int & v)
{
  struct lambda D.94070;
  struct lambda D.85330;

  sigc::lambda<int&>::lambda (&D.85330, v);
  try
    {
      D.94070 = D.85330;
      return D.94070;
    }
  finally
    {
      D.85330 = {CLOBBER};
    }
}


sigc::lambda<sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<T_type>, typename sigc::unwrap_lambda_type<T_arg>::type> > sigc::lambda<T_type>::operator=(const T_arg&) const [with T_arg = sigc::lambda<sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> > >; T_type = int&; typename sigc::unwrap_lambda_type<T_arg>::type = sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> >] (const struct lambda * const this, const struct lambda & a)
{
  struct lambda_operator_type D.85431;
  const struct lambda_operator & D.94074;
  const struct lambda D.85430;
  int & D.94075;
  typedef struct lambda_operator_type lambda_operator_type;

  D.94074 = sigc::unwrap_lambda_value<sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> > > (a);
  D.94075 = this->D.57181.value_;
  sigc::lambda<int&>::lambda (&D.85430, D.94075);
  try
    {
      sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> > >::lambda_operator (&D.85431, &D.85430, D.94074);
      try
        {
          sigc::lambda<sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> > > >::lambda (&<retval>, &D.85431);
          return <retval>;
        }
      finally
        {
          D.85431 = {CLOBBER};
        }
    }
  finally
    {
      D.85430 = {CLOBBER};
    }
}


const T_type& sigc::unwrap_lambda_value(const sigc::lambda<T_type>&) [with T_type = sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> >] (const struct lambda & a)
{
  const struct lambda_operator & D.94081;

  D.94081 = &a->D.60119.value_;
  return D.94081;
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::other<sigc::assign>; T_type1 = sigc::lambda<int&>; T_type2 = sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> >; typename sigc::type_trait<T_derived>::take = const sigc::lambda<int&>&; typename sigc::type_trait<T_arg3>::take = const sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> >&] (struct lambda_operator * const this, const struct lambda & a1, const struct lambda_operator & a2)
{
  sigc::lambda_base::lambda_base (this);
  this->arg1_ = *a1;
  this->arg2_ = *a2;
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> > >; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> > >&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.94083;

  D.94083 = &this->D.60946;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> > >, true>::lambda_core (D.94083, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> > >] (struct lambda_core * const this, const struct lambda_operator & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2) const [with T_arg1 = int; T_arg2 = int; T_type = sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> > >; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct lambda_core * const this, int _A_1, int _A_2)
{
  type D.94084;
  const struct lambda_operator * D.94085;

  D.94085 = &this->value_;
  D.94084 = sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> > >::operator()<int&, int&> (D.94085, &_A_1, &_A_2);
  return D.94084;
}


typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()(T_arg1, T_arg2) const [with T_arg1 = int&; T_arg2 = int&; T_action = sigc::other<sigc::assign>; T_type1 = sigc::lambda<int&>; T_type2 = sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> >; typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct lambda_operator * const this, int & _A_1, int & _A_2)
{
  type D.94088;
  const struct arg2_type * D.94089;
  int D.94090;
  const struct lambda_core * D.94091;
  int & D.94092;

  D.94089 = &this->arg2_;
  D.94090 = sigc::lambda_operator<sigc::comma, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>, sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2> >::operator()<int&, int&> (D.94089, _A_1, _A_2);
  D.94091 = &this->arg1_.D.57181;
  D.94092 = sigc::internal::lambda_core<int&, false>::operator()<int&, int&> (D.94091, _A_1, _A_2);
  D.94088 = sigc::lambda_action<sigc::other<sigc::assign> >::do_action<int&, int> (D.94092, D.94090);
  return D.94088;
}


typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()(T_arg1, T_arg2) const [with T_arg1 = int&; T_arg2 = int&; T_action = sigc::comma; T_type1 = sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>; T_type2 = sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2>; typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct lambda_operator * const this, int & _A_1, int & _A_2)
{
  type D.94095;
  const struct arg2_type * D.94096;
  int D.94097;
  const struct arg1_type * D.94098;
  int D.94099;

  D.94096 = &this->arg2_;
  D.94097 = sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select2>::operator()<int&, int&> (D.94096, _A_1, _A_2);
  D.94098 = &this->arg1_;
  D.94099 = sigc::lambda_operator<sigc::other<sigc::assign>, sigc::lambda<int&>, sigc::internal::lambda_select1>::operator()<int&, int&> (D.94098, _A_1, _A_2);
  D.94095 = sigc::lambda_action<sigc::comma>::do_action<int, int> (D.94099, D.94097);
  return D.94095;
}


typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()(T_arg1, T_arg2) const [with T_arg1 = int&; T_arg2 = int&; T_action = sigc::other<sigc::assign>; T_type1 = sigc::lambda<int&>; T_type2 = sigc::internal::lambda_select2; typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct lambda_operator * const this, int & _A_1, int & _A_2)
{
  type D.94101;
  const struct arg2_type * D.94102;
  int & D.94103;
  const struct lambda_core * D.94104;
  int & D.94105;

  D.94102 = &this->arg2_;
  D.94103 = sigc::internal::lambda_select2::operator()<int&, int&> (D.94102, _A_1, _A_2);
  D.94104 = &this->arg1_.D.57181;
  D.94105 = sigc::internal::lambda_core<int&, false>::operator()<int&, int&> (D.94104, _A_1, _A_2);
  D.94101 = sigc::lambda_action<sigc::other<sigc::assign> >::do_action<int&, int&> (D.94105, D.94103);
  return D.94101;
}


typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()(T_arg1, T_arg2) const [with T_arg1 = int&; T_arg2 = int&; T_action = sigc::other<sigc::assign>; T_type1 = sigc::lambda<int&>; T_type2 = sigc::internal::lambda_select1; typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct lambda_operator * const this, int & _A_1, int & _A_2)
{
  type D.94107;
  const struct arg2_type * D.94108;
  int & D.94109;
  const struct lambda_core * D.94110;
  int & D.94111;

  D.94108 = &this->arg2_;
  D.94109 = sigc::internal::lambda_select1::operator()<int&, int&> (D.94108, _A_1, _A_2);
  D.94110 = &this->arg1_.D.57181;
  D.94111 = sigc::internal::lambda_core<int&, false>::operator()<int&, int&> (D.94110, _A_1, _A_2);
  D.94107 = sigc::lambda_action<sigc::other<sigc::assign> >::do_action<int&, int&> (D.94111, D.94109);
  return D.94107;
}


static typename sigc::lambda_action_deduce_result_type<sigc::comma, T_arg1, T_arg2>::type sigc::lambda_action<sigc::comma>::do_action(T_arg1, T_arg2) [with T_arg1 = int; T_arg2 = int; typename sigc::lambda_action_deduce_result_type<sigc::comma, T_arg1, T_arg2>::type = int] (int _A_1, int _A_2)
{
  type D.94113;

  D.94113 = _A_2;
  return D.94113;
}


sigc::internal::lambda_core<T_type, false>::result_type sigc::internal::lambda_core<T_type, false>::operator()(T_arg1, T_arg2) const [with T_arg1 = int&; T_arg2 = int&; T_type = int&; sigc::internal::lambda_core<T_type, false>::result_type = int&] (const struct lambda_core * const this, int & D.88392, int & D.88393)
{
  int & D.94115;

  D.94115 = this->value_;
  return D.94115;
}


static typename sigc::lambda_action_deduce_result_type<sigc::other<sigc::assign>, T_arg1, T_arg2>::type sigc::lambda_action<sigc::other<sigc::assign> >::do_action(T_arg1, T_arg2) [with T_arg1 = int&; T_arg2 = int; typename sigc::lambda_action_deduce_result_type<sigc::other<sigc::assign>, T_arg1, T_arg2>::type = int] (int & _A_1, int _A_2)
{
  type D.94117;

  *_A_1 = _A_2;
  D.94117 = *_A_1;
  return D.94117;
}


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.94121;
  int (*__vtbl_ptr_type) () * D.94122;
  long int D.94123;
  sizetype D.94124;
  struct basic_ios * D.94125;
  long unsigned int D.94127;
  long int D.94128;
  struct basic_ostream & D.94129;

  if (__s == 0B) goto <D.94119>; else goto <D.94120>;
  <D.94119>:
  D.94121 = __out->_vptr.basic_ostream;
  D.94122 = D.94121 + 18446744073709551592;
  D.94123 = MEM[(long int *)D.94122];
  D.94124 = (sizetype) D.94123;
  D.94125 = __out + D.94124;
  std::basic_ios<char>::setstate (D.94125, 1);
  goto <D.94126>;
  <D.94120>:
  D.94127 = std::char_traits<char>::length (__s);
  D.94128 = (long int) D.94127;
  std::__ostream_insert<char, std::char_traits<char> > (__out, __s, D.94128);
  <D.94126>:
  D.94129 = __out;
  return D.94129;
}


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.94131;
  _Ios_Iostate D.94132;

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


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

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


std::_Ios_Iostate std::operator|(std::_Ios_Iostate, std::_Ios_Iostate) (_Ios_Iostate __a, _Ios_Iostate __b)
{
  _Ios_Iostate D.94136;
  int __a.6;
  int __b.7;
  int D.94139;

  __a.6 = (int) __a;
  __b.7 = (int) __b;
  D.94139 = __a.6 | __b.7;
  D.94136 = (_Ios_Iostate) D.94139;
  return D.94136;
}


sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, typename sigc::unwrap_reference<T_type>::type, T_arg2> > sigc::operator<<(const T_arg1&, const sigc::lambda<T_type1>&) [with T_arg1 = sigc::reference_wrapper<std::basic_ostringstream<char> >; T_arg2 = sigc::internal::lambda_select1; typename sigc::unwrap_reference<T_type>::type = std::basic_ostringstream<char>&] (const struct reference_wrapper & a1, const struct lambda & a2)
{
  struct operator_type D.85574;
  const struct lambda_select1 * D.94142;
  struct basic_ostringstream & D.94143;
  typedef struct operator_type operator_type;

  D.94142 = &a2->D.40074.value_;
  D.94143 = sigc::reference_wrapper<std::basic_ostringstream<char> >::operator std::basic_ostringstream<char>& (a1);
  sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>::lambda_operator (&D.85574, D.94143, D.94142);
  try
    {
      sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1> >::lambda (&<retval>, &D.85574);
      return <retval>;
    }
  finally
    {
      D.85574 = {CLOBBER};
    }
}


sigc::reference_wrapper<T_type>::operator T_type&() const [with T_type = std::basic_ostringstream<char>] (const struct reference_wrapper * const this)
{
  struct basic_ostringstream & D.94147;

  D.94147 = this->value_;
  return D.94147;
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::bitwise<sigc::leftshift>; T_type1 = std::basic_ostringstream<char>&; T_type2 = sigc::internal::lambda_select1; typename sigc::type_trait<T_derived>::take = std::basic_ostringstream<char>&; typename sigc::type_trait<T_arg3>::take = const sigc::internal::lambda_select1&] (struct lambda_operator * const this, struct basic_ostringstream & a1, const struct lambda_select1 & a2)
{
  struct arg1_type * D.94149;

  sigc::lambda_base::lambda_base (this);
  D.94149 = &this->arg1_;
  sigc::lambda<std::basic_ostringstream<char>&>::lambda (D.94149, a1);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = std::basic_ostringstream<char>&; typename sigc::type_trait<T_base>::take = std::basic_ostringstream<char>&] (struct lambda * const this, struct basic_ostringstream & v)
{
  struct lambda_core * D.94150;

  D.94150 = &this->D.61429;
  sigc::internal::lambda_core<std::basic_ostringstream<char>&, false>::lambda_core (D.94150, v);
}


sigc::internal::lambda_core<T_type, false>::lambda_core(typename sigc::type_trait<T_base>::take) [with T_type = std::basic_ostringstream<char>&; typename sigc::type_trait<T_base>::take = std::basic_ostringstream<char>&] (struct lambda_core * const this, struct basic_ostringstream & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = v;
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.94151;

  D.94151 = &this->D.62239;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, true>::lambda_core (D.94151, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>] (struct lambda_core * const this, const struct lambda_operator & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


sigc::reference_wrapper<T_type> sigc::ref(T_type&) [with T_type = std::basic_ostringstream<char>] (struct basic_ostringstream & v)
{
  struct reference_wrapper D.94152;
  struct reference_wrapper D.85562;

  sigc::reference_wrapper<std::basic_ostringstream<char> >::reference_wrapper (&D.85562, v);
  try
    {
      D.94152 = D.85562;
      return D.94152;
    }
  finally
    {
      D.85562 = {CLOBBER};
    }
}


sigc::reference_wrapper<T_type>::reference_wrapper(T_type&) [with T_type = std::basic_ostringstream<char>] (struct reference_wrapper * const this, struct basic_ostringstream & v)
{
  this->value_ = v;
}


sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, typename sigc::unwrap_reference<T_type>::type, T_arg2> > sigc::operator<<(const T_arg1&, const sigc::lambda<T_type1>&) [with T_arg1 = sigc::reference_wrapper<std::basic_ostringstream<char> >; T_arg2 = sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1>; typename sigc::unwrap_reference<T_type>::type = std::basic_ostringstream<char>&] (const struct reference_wrapper & a1, const struct lambda & a2)
{
  struct operator_type D.85798;
  const struct lambda_operator_convert * D.94156;
  struct basic_ostringstream & D.94157;
  typedef struct operator_type operator_type;

  D.94156 = &a2->D.64429.value_;
  D.94157 = sigc::reference_wrapper<std::basic_ostringstream<char> >::operator std::basic_ostringstream<char>& (a1);
  sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >::lambda_operator (&D.85798, D.94157, D.94156);
  try
    {
      sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> > >::lambda (&<retval>, &D.85798);
      return <retval>;
    }
  finally
    {
      D.85798 = {CLOBBER};
    }
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::bitwise<sigc::leftshift>; T_type1 = std::basic_ostringstream<char>&; T_type2 = sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1>; typename sigc::type_trait<T_derived>::take = std::basic_ostringstream<char>&; typename sigc::type_trait<T_arg3>::take = const sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1>&] (struct lambda_operator * const this, struct basic_ostringstream & a1, const struct lambda_operator_convert & a2)
{
  struct arg1_type * D.94161;

  sigc::lambda_base::lambda_base (this);
  D.94161 = &this->arg1_;
  sigc::lambda<std::basic_ostringstream<char>&>::lambda (D.94161, a1);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.94162;

  D.94162 = &this->D.65257;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, true>::lambda_core (D.94162, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >] (struct lambda_core * const this, const struct lambda_operator & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, T_arg1, typename sigc::unwrap_reference<T_arg2>::type> > sigc::operator<<(const sigc::lambda<T_type>&, const T_arg2&) [with T_arg1 = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >; T_arg2 = std::basic_string<char>; typename sigc::unwrap_reference<T_arg2>::type = std::basic_string<char>] (const struct lambda & a1, const struct basic_string & a2)
{
  struct operator_type D.85820;
  const struct lambda_operator * D.94164;
  typedef struct operator_type operator_type;

  D.94164 = &a1->D.65257.value_;
  sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, std::basic_string<char> >::lambda_operator (&D.85820, D.94164, a2);
  try
    {
      sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, std::basic_string<char> > >::lambda (<retval>, &D.85820);
      return <retval>;
    }
  finally
    {
      sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, std::basic_string<char> >::~lambda_operator (&D.85820);
      D.85820 = {CLOBBER};
    }
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::bitwise<sigc::leftshift>; T_type1 = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >; T_type2 = std::basic_string<char>; typename sigc::type_trait<T_derived>::take = const sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >&; typename sigc::type_trait<T_arg3>::take = const std::basic_string<char>&] (struct lambda_operator * const this, const struct lambda_operator & a1, const struct basic_string & a2)
{
  struct arg2_type * D.94168;

  sigc::lambda_base::lambda_base (this);
  this->arg1_ = *a1;
  D.94168 = &this->arg2_;
  sigc::lambda<std::basic_string<char> >::lambda (D.94168, a2);
  try
    {

    }
  catch
    {
      D.94168 = &this->arg2_;
      sigc::lambda<std::basic_string<char> >::~lambda (D.94168);
    }
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = std::basic_string<char>; typename sigc::type_trait<T_base>::take = const std::basic_string<char>&] (struct lambda * const this, const struct basic_string & v)
{
  struct lambda_core * D.94169;

  D.94169 = &this->D.62584;
  sigc::internal::lambda_core<std::basic_string<char>, false>::lambda_core (D.94169, v);
  try
    {

    }
  catch
    {
      D.94169 = &this->D.62584;
      sigc::internal::lambda_core<std::basic_string<char>, false>::~lambda_core (D.94169);
    }
}


sigc::internal::lambda_core<T_type, false>::lambda_core(typename sigc::type_trait<T_base>::take) [with T_type = std::basic_string<char>; typename sigc::type_trait<T_base>::take = const std::basic_string<char>&] (struct lambda_core * const this, const struct basic_string & v)
{
  struct basic_string * D.94170;

  sigc::lambda_base::lambda_base (this);
  D.94170 = &this->value_;
  std::basic_string<char>::basic_string (D.94170, v);
  try
    {

    }
  catch
    {
      D.94170 = &this->value_;
      std::basic_string<char>::~basic_string (D.94170);
    }
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, std::basic_string<char> >; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, std::basic_string<char> >&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.94171;

  D.94171 = &this->D.66079;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, std::basic_string<char> >, true>::lambda_core (D.94171, v);
  try
    {

    }
  catch
    {
      D.94171 = &this->D.66079;
      sigc::internal::lambda_core<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, std::basic_string<char> >, true>::~lambda_core (D.94171);
    }
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, std::basic_string<char> >] (struct lambda_core * const this, const struct lambda_operator & v)
{
  struct lambda_operator * D.94172;

  sigc::lambda_base::lambda_base (this);
  D.94172 = &this->value_;
  sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, std::basic_string<char> >::lambda_operator (D.94172, v);
  try
    {

    }
  catch
    {
      D.94172 = &this->value_;
      sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, std::basic_string<char> >::~lambda_operator (D.94172);
    }
}


sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, std::basic_string<char> >::lambda_operator(const sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, std::basic_string<char> >&) (struct lambda_operator * const this, const struct lambda_operator & D.85819)
{
  const struct arg2_type * D.94173;
  struct arg2_type * D.94174;

  this->arg1_ = D.85819->arg1_;
  D.94173 = &D.85819->arg2_;
  D.94174 = &this->arg2_;
  sigc::lambda<std::basic_string<char> >::lambda (D.94174, D.94173);
  try
    {

    }
  catch
    {
      D.94174 = &this->arg2_;
      sigc::lambda<std::basic_string<char> >::~lambda (D.94174);
    }
}


sigc::lambda<std::basic_string<char> >::lambda(const sigc::lambda<std::basic_string<char> >&) (struct lambda * const this, const struct lambda & D.85619)
{
  const struct lambda_core * D.94175;
  struct lambda_core * D.94176;

  D.94175 = &D.85619->D.62584;
  D.94176 = &this->D.62584;
  sigc::internal::lambda_core<std::basic_string<char>, false>::lambda_core (D.94176, D.94175);
  try
    {

    }
  catch
    {
      D.94176 = &this->D.62584;
      sigc::internal::lambda_core<std::basic_string<char>, false>::~lambda_core (D.94176);
    }
}


sigc::internal::lambda_core<std::basic_string<char>, false>::lambda_core(const sigc::internal::lambda_core<std::basic_string<char>, false>&) (struct lambda_core * const this, const struct lambda_core & D.85610)
{
  const struct basic_string * D.94177;
  struct basic_string * D.94178;

  D.94177 = &D.85610->value_;
  D.94178 = &this->value_;
  std::basic_string<char>::basic_string (D.94178, D.94177);
  try
    {

    }
  catch
    {
      D.94178 = &this->value_;
      std::basic_string<char>::~basic_string (D.94178);
    }
}


sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, std::basic_string<char> >::~lambda_operator() (struct lambda_operator * const this)
{
  struct arg2_type * D.94179;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.94179 = &this->arg2_;
            sigc::lambda<std::basic_string<char> >::~lambda (D.94179);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.66126>:
}


sigc::lambda<std::basic_string<char> >::~lambda() (struct lambda * const this)
{
  struct lambda_core * D.94181;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.94181 = &this->D.62584;
            sigc::internal::lambda_core<std::basic_string<char>, false>::~lambda_core (D.94181);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.63476>:
}


sigc::internal::lambda_core<std::basic_string<char>, false>::~lambda_core() (struct lambda_core * const this)
{
  struct basic_string * D.94183;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.94183 = &this->value_;
            std::basic_string<char>::~basic_string (D.94183);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.63471>:
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1) const [with T_arg1 = double; T_type = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, std::basic_string<char> >; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1>::type = std::basic_ostream<char>&] (const struct lambda_core * const this, double _A_1)
{
  struct ostream & D.94185;
  const struct lambda_operator * D.94186;

  D.94186 = &this->value_;
  D.94185 = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, std::basic_string<char> >::operator()<double&> (D.94186, &_A_1);
  return D.94185;
}


typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1>::type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()(T_arg1) const [with T_arg1 = double&; T_action = sigc::bitwise<sigc::leftshift>; T_type1 = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >; T_type2 = std::basic_string<char>; typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1>::type = std::basic_ostream<char>&] (const struct lambda_operator * const this, double & _A_1)
{
  struct ostream & D.94189;
  struct result_type D.88793;
  const struct lambda_core * D.94190;
  const struct arg1_type * D.94191;
  struct ostream & D.94192;

  D.94190 = &this->arg2_.D.62584;
  D.88793 = sigc::internal::lambda_core<std::basic_string<char>, false>::operator()<double&> (D.94190, _A_1); [return slot optimization]
  try
    {
      D.94191 = &this->arg1_;
      D.94192 = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >::operator()<double&> (D.94191, _A_1);
      D.94189 = sigc::lambda_action<sigc::bitwise<sigc::leftshift> >::do_action<std::basic_ostream<char>&, std::basic_string<char> > (D.94192, &D.88793);
      return D.94189;
    }
  finally
    {
      std::basic_string<char>::~basic_string (&D.88793);
      D.88793 = {CLOBBER};
    }
}


sigc::internal::lambda_core<T_type, false>::result_type sigc::internal::lambda_core<T_type, false>::operator()(T_arg1) const [with T_arg1 = double&; T_type = std::basic_string<char>; sigc::internal::lambda_core<T_type, false>::result_type = std::basic_string<char>] (const struct lambda_core * const this, double & D.88792)
{
  const struct basic_string * D.94199;

  D.94199 = &this->value_;
  std::basic_string<char>::basic_string (<retval>, D.94199);
  return <retval>;
}


typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1>::type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()(T_arg1) const [with T_arg1 = double&; T_action = sigc::bitwise<sigc::leftshift>; T_type1 = std::basic_ostringstream<char>&; T_type2 = sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1>; typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1>::type = std::basic_ostream<char>&] (const struct lambda_operator * const this, double & _A_1)
{
  struct ostream & D.94201;
  const struct arg2_type * D.94202;
  int D.94203;
  const struct lambda_core * D.94204;
  struct basic_ostringstream & D.94205;

  D.94202 = &this->arg2_;
  D.94203 = sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1>::operator()<double&> (D.94202, _A_1);
  D.94204 = &this->arg1_.D.61429;
  D.94205 = sigc::internal::lambda_core<std::basic_ostringstream<char>&, false>::operator()<double&> (D.94204, _A_1);
  D.94201 = sigc::lambda_action<sigc::bitwise<sigc::leftshift> >::do_action<std::basic_ostringstream<char>&, int> (D.94205, D.94203);
  return D.94201;
}


typename sigc::lambda_operator_convert<T_action, T_type, T_arg>::deduce_result_type<T_arg1>::type sigc::lambda_operator_convert<T_action, T_type, T_arg>::operator()(T_arg1) const [with T_arg1 = double&; T_action = sigc::cast_<sigc::static_>; T_type = int; T_arg = sigc::internal::lambda_select1; typename sigc::lambda_operator_convert<T_action, T_type, T_arg>::deduce_result_type<T_arg1>::type = int] (const struct lambda_operator_convert * const this, double & _A_1)
{
  type D.94209;
  const struct arg_type * D.94210;
  double & D.94211;

  D.94210 = &this->arg_;
  D.94211 = sigc::internal::lambda_select1::operator()<double&> (D.94210, _A_1);
  D.94209 = sigc::lambda_action_convert<sigc::cast_<sigc::static_>, int>::do_action<double&> (D.94211);
  return D.94209;
}


T_arg1 sigc::internal::lambda_select1::operator()(T_arg1) const [with T_arg1 = double&] (const struct lambda_select1 * const this, double & _A_1)
{
  double & D.94213;

  D.94213 = _A_1;
  return D.94213;
}


static typename sigc::lambda_action_convert_deduce_result_type<sigc::cast_<sigc::static_>, T_type, T_arg>::type sigc::lambda_action_convert<sigc::cast_<sigc::static_>, T_type>::do_action(T_arg) [with T_arg = double&; T_type = int; typename sigc::lambda_action_convert_deduce_result_type<sigc::cast_<sigc::static_>, T_type, T_arg>::type = int] (double & _Aa)
{
  type D.94215;
  double D.94216;

  D.94216 = *_Aa;
  D.94215 = (type) D.94216;
  return D.94215;
}


sigc::internal::lambda_core<T_type, false>::result_type sigc::internal::lambda_core<T_type, false>::operator()(T_arg1) const [with T_arg1 = double&; T_type = std::basic_ostringstream<char>&; sigc::internal::lambda_core<T_type, false>::result_type = std::basic_ostringstream<char>&] (const struct lambda_core * const this, double & D.91630)
{
  struct basic_ostringstream & D.94218;

  D.94218 = this->value_;
  return D.94218;
}


static typename sigc::lambda_action_deduce_result_type<sigc::bitwise<sigc::leftshift>, T_arg1, T_arg2>::type sigc::lambda_action<sigc::bitwise<sigc::leftshift> >::do_action(T_arg1, T_arg2) [with T_arg1 = std::basic_ostringstream<char>&; T_arg2 = int; typename sigc::lambda_action_deduce_result_type<sigc::bitwise<sigc::leftshift>, T_arg1, T_arg2>::type = std::basic_ostream<char>&] (struct basic_ostringstream & _A_1, int _A_2)
{
  struct ostream & D.94220;
  struct basic_ostream * D.94221;

  D.94221 = &_A_1->D.22312;
  D.94220 = std::basic_ostream<char>::operator<< (D.94221, _A_2);
  return D.94220;
}


static typename sigc::lambda_action_deduce_result_type<sigc::bitwise<sigc::leftshift>, T_arg1, T_arg2>::type sigc::lambda_action<sigc::bitwise<sigc::leftshift> >::do_action(T_arg1, T_arg2) [with T_arg1 = std::basic_ostream<char>&; T_arg2 = std::basic_string<char>; typename sigc::lambda_action_deduce_result_type<sigc::bitwise<sigc::leftshift>, T_arg1, T_arg2>::type = std::basic_ostream<char>&] (struct basic_ostream & _A_1, struct basic_string & restrict _A_2)
{
  struct ostream & D.94224;

  D.94224 = std::operator<< <char, std::char_traits<char>, std::allocator<char> > (_A_1, _A_2);
  return D.94224;
}


sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, T_arg1, typename sigc::unwrap_reference<T_arg2>::type> > sigc::operator<<(const sigc::lambda<T_type>&, const T_arg2&) [with T_arg1 = std::basic_ostringstream<char>&; T_arg2 = int; typename sigc::unwrap_reference<T_arg2>::type = int] (const struct lambda & a1, const int & a2)
{
  struct operator_type D.85990;
  struct basic_ostringstream & D.94228;
  typedef struct operator_type operator_type;

  D.94228 = a1->D.61429.value_;
  sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, int>::lambda_operator (&D.85990, D.94228, a2);
  try
    {
      sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, int> >::lambda (&<retval>, &D.85990);
      return <retval>;
    }
  finally
    {
      D.85990 = {CLOBBER};
    }
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::bitwise<sigc::leftshift>; T_type1 = std::basic_ostringstream<char>&; T_type2 = int; typename sigc::type_trait<T_derived>::take = std::basic_ostringstream<char>&; typename sigc::type_trait<T_arg3>::take = const int&] (struct lambda_operator * const this, struct basic_ostringstream & a1, const int & a2)
{
  struct arg1_type * D.94232;
  struct arg2_type * D.94233;

  sigc::lambda_base::lambda_base (this);
  D.94232 = &this->arg1_;
  sigc::lambda<std::basic_ostringstream<char>&>::lambda (D.94232, a1);
  D.94233 = &this->arg2_;
  sigc::lambda<int>::lambda (D.94233, a2);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, int>; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, int>&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.94234;

  D.94234 = &this->D.67103;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, int>, true>::lambda_core (D.94234, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, int>] (struct lambda_core * const this, const struct lambda_operator & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, T_arg1, T_arg2> > sigc::operator<<(const sigc::lambda<T_type>&, const sigc::lambda<T_type1>&) [with T_arg1 = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, int>; T_arg2 = const char (&)[2]] (const struct lambda & a1, const struct lambda & a2)
{
  struct operator_type D.86023;
  const char[2] & D.94236;
  const struct lambda_operator * D.94237;
  typedef struct operator_type operator_type;

  D.94236 = a2->D.67418.value_;
  D.94237 = &a1->D.67103.value_;
  sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, int>, const char (&)[2]>::lambda_operator (&D.86023, D.94237, D.94236);
  try
    {
      sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, int>, const char (&)[2]> >::lambda (&<retval>, &D.86023);
      return <retval>;
    }
  finally
    {
      D.86023 = {CLOBBER};
    }
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::bitwise<sigc::leftshift>; T_type1 = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, int>; T_type2 = const char (&)[2]; typename sigc::type_trait<T_derived>::take = const sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, int>&; typename sigc::type_trait<T_arg3>::take = const char (&)[2]] (struct lambda_operator * const this, const struct lambda_operator & a1, const char[2] & a2)
{
  struct arg2_type * D.94241;

  sigc::lambda_base::lambda_base (this);
  this->arg1_ = *a1;
  D.94241 = &this->arg2_;
  sigc::lambda<const char (&)[2]>::lambda (D.94241, a2);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = const char (&)[2]; typename sigc::type_trait<T_base>::take = const char (&)[2]] (struct lambda * const this, const char[2] & v)
{
  struct lambda_core * D.94242;

  D.94242 = &this->D.67418;
  sigc::internal::lambda_core<const char (&)[2], false>::lambda_core (D.94242, v);
}


sigc::internal::lambda_core<T_type, false>::lambda_core(typename sigc::type_trait<T_base>::take) [with T_type = const char (&)[2]; typename sigc::type_trait<T_base>::take = const char (&)[2]] (struct lambda_core * const this, const char[2] & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = v;
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, int>, const char (&)[2]>; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, int>, const char (&)[2]>&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.94243;

  D.94243 = &this->D.68271;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, int>, const char (&)[2]>, true>::lambda_core (D.94243, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, int>, const char (&)[2]>] (struct lambda_core * const this, const struct lambda_operator & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


sigc::internal::lambda_core<T_type, true>::result_type sigc::internal::lambda_core<T_type, true>::operator()() const [with T_type = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, int>, const char (&)[2]>; sigc::internal::lambda_core<T_type, true>::result_type = std::basic_ostream<char>&] (const struct lambda_core * const this)
{
  struct ostream & D.94244;
  const struct lambda_operator * D.94245;

  D.94245 = &this->value_;
  D.94244 = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, int>, const char (&)[2]>::operator() (D.94245);
  return D.94244;
}


sigc::lambda_operator<T_action, T_type1, T_type2>::result_type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()() const [with T_action = sigc::bitwise<sigc::leftshift>; T_type1 = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, int>; T_type2 = const char (&)[2]; sigc::lambda_operator<T_action, T_type1, T_type2>::result_type = std::basic_ostream<char>&] (const struct lambda_operator * const this)
{
  struct ostream & D.94248;
  const struct lambda_core * D.94249;
  const char[2] & D.94250;
  const struct arg1_type * D.94251;
  struct ostream & D.94252;

  D.94249 = &this->arg2_.D.67418;
  D.94250 = sigc::internal::lambda_core<const char (&)[2], false>::operator() (D.94249);
  D.94251 = &this->arg1_;
  D.94252 = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, int>::operator() (D.94251);
  D.94248 = sigc::lambda_action<sigc::bitwise<sigc::leftshift> >::do_action<std::basic_ostream<char>&, const char (&)[2]> (D.94252, D.94250);
  return D.94248;
}


sigc::internal::lambda_core<T_type, false>::result_type sigc::internal::lambda_core<T_type, false>::operator()() const [with T_type = const char (&)[2]; sigc::internal::lambda_core<T_type, false>::result_type = const char (&)[2]] (const struct lambda_core * const this)
{
  const char[2] & D.94256;

  D.94256 = this->value_;
  return D.94256;
}


sigc::lambda_operator<T_action, T_type1, T_type2>::result_type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()() const [with T_action = sigc::bitwise<sigc::leftshift>; T_type1 = std::basic_ostringstream<char>&; T_type2 = int; sigc::lambda_operator<T_action, T_type1, T_type2>::result_type = std::basic_ostream<char>&] (const struct lambda_operator * const this)
{
  struct ostream & D.94258;
  const struct lambda_core * D.94259;
  int D.94260;
  const struct lambda_core * D.94261;
  struct basic_ostringstream & D.94262;

  D.94259 = &this->arg2_.D.41753;
  D.94260 = sigc::internal::lambda_core<int, false>::operator() (D.94259);
  D.94261 = &this->arg1_.D.61429;
  D.94262 = sigc::internal::lambda_core<std::basic_ostringstream<char>&, false>::operator() (D.94261);
  D.94258 = sigc::lambda_action<sigc::bitwise<sigc::leftshift> >::do_action<std::basic_ostringstream<char>&, int> (D.94262, D.94260);
  return D.94258;
}


sigc::internal::lambda_core<T_type, false>::result_type sigc::internal::lambda_core<T_type, false>::operator()() const [with T_type = std::basic_ostringstream<char>&; sigc::internal::lambda_core<T_type, false>::result_type = std::basic_ostringstream<char>&] (const struct lambda_core * const this)
{
  struct basic_ostringstream & D.94265;

  D.94265 = this->value_;
  return D.94265;
}


static typename sigc::lambda_action_deduce_result_type<sigc::bitwise<sigc::leftshift>, T_arg1, T_arg2>::type sigc::lambda_action<sigc::bitwise<sigc::leftshift> >::do_action(T_arg1, T_arg2) [with T_arg1 = std::basic_ostream<char>&; T_arg2 = const char (&)[2]; typename sigc::lambda_action_deduce_result_type<sigc::bitwise<sigc::leftshift>, T_arg1, T_arg2>::type = std::basic_ostream<char>&] (struct basic_ostream & _A_1, const char[2] & _A_2)
{
  struct ostream & D.94267;

  D.94267 = std::operator<< <std::char_traits<char> > (_A_1, _A_2);
  return D.94267;
}


sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, T_arg1, T_arg2> > sigc::operator<<(const sigc::lambda<T_type>&, const sigc::lambda<T_type1>&) [with T_arg1 = std::basic_ostringstream<char>&; T_arg2 = sigc::internal::lambda_select1] (const struct lambda & a1, const struct lambda & a2)
{
  struct operator_type D.86037;
  const struct lambda_select1 * D.94271;
  struct basic_ostringstream & D.94272;
  typedef struct operator_type operator_type;

  D.94271 = &a2->D.40074.value_;
  D.94272 = a1->D.61429.value_;
  sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>::lambda_operator (&D.86037, D.94272, D.94271);
  try
    {
      sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1> >::lambda (&<retval>, &D.86037);
      return <retval>;
    }
  finally
    {
      D.86037 = {CLOBBER};
    }
}


sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, T_arg1, typename sigc::unwrap_reference<T_arg2>::type> > sigc::operator<<(const sigc::lambda<T_type>&, const T_arg2&) [with T_arg1 = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>; T_arg2 = std::basic_string<char>; typename sigc::unwrap_reference<T_arg2>::type = std::basic_string<char>] (const struct lambda & a1, const struct basic_string & a2)
{
  struct operator_type D.85629;
  const struct lambda_operator * D.94277;
  typedef struct operator_type operator_type;

  D.94277 = &a1->D.62239.value_;
  sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> >::lambda_operator (&D.85629, D.94277, a2);
  try
    {
      sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> > >::lambda (<retval>, &D.85629);
      return <retval>;
    }
  finally
    {
      sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> >::~lambda_operator (&D.85629);
      D.85629 = {CLOBBER};
    }
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::bitwise<sigc::leftshift>; T_type1 = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>; T_type2 = std::basic_string<char>; typename sigc::type_trait<T_derived>::take = const sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>&; typename sigc::type_trait<T_arg3>::take = const std::basic_string<char>&] (struct lambda_operator * const this, const struct lambda_operator & a1, const struct basic_string & a2)
{
  struct arg2_type * D.94281;

  sigc::lambda_base::lambda_base (this);
  this->arg1_ = *a1;
  D.94281 = &this->arg2_;
  sigc::lambda<std::basic_string<char> >::lambda (D.94281, a2);
  try
    {

    }
  catch
    {
      D.94281 = &this->arg2_;
      sigc::lambda<std::basic_string<char> >::~lambda (D.94281);
    }
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> >; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> >&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.94282;

  D.94282 = &this->D.63393;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> >, true>::lambda_core (D.94282, v);
  try
    {

    }
  catch
    {
      D.94282 = &this->D.63393;
      sigc::internal::lambda_core<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> >, true>::~lambda_core (D.94282);
    }
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> >] (struct lambda_core * const this, const struct lambda_operator & v)
{
  struct lambda_operator * D.94283;

  sigc::lambda_base::lambda_base (this);
  D.94283 = &this->value_;
  sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> >::lambda_operator (D.94283, v);
  try
    {

    }
  catch
    {
      D.94283 = &this->value_;
      sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> >::~lambda_operator (D.94283);
    }
}


sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> >::lambda_operator(const sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> >&) (struct lambda_operator * const this, const struct lambda_operator & D.85628)
{
  const struct arg2_type * D.94284;
  struct arg2_type * D.94285;

  this->arg1_ = D.85628->arg1_;
  D.94284 = &D.85628->arg2_;
  D.94285 = &this->arg2_;
  sigc::lambda<std::basic_string<char> >::lambda (D.94285, D.94284);
  try
    {

    }
  catch
    {
      D.94285 = &this->arg2_;
      sigc::lambda<std::basic_string<char> >::~lambda (D.94285);
    }
}


sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> >::~lambda_operator() (struct lambda_operator * const this)
{
  struct arg2_type * D.94286;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.94286 = &this->arg2_;
            sigc::lambda<std::basic_string<char> >::~lambda (D.94286);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.63481>:
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1) const [with T_arg1 = const char*; T_type = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> >; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1>::type = std::basic_ostream<char>&] (const struct lambda_core * const this, const char * _A_1)
{
  struct ostream & D.94288;
  const struct lambda_operator * D.94289;

  D.94289 = &this->value_;
  D.94288 = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> >::operator()<const char*&> (D.94289, &_A_1);
  return D.94288;
}


typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1>::type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()(T_arg1) const [with T_arg1 = const char*&; T_action = sigc::bitwise<sigc::leftshift>; T_type1 = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>; T_type2 = std::basic_string<char>; typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1>::type = std::basic_ostream<char>&] (const struct lambda_operator * const this, const char * & _A_1)
{
  struct ostream & D.94292;
  struct result_type D.88631;
  const struct lambda_core * D.94293;
  const struct arg1_type * D.94294;
  struct ostream & D.94295;

  D.94293 = &this->arg2_.D.62584;
  D.88631 = sigc::internal::lambda_core<std::basic_string<char>, false>::operator()<const char*&> (D.94293, _A_1); [return slot optimization]
  try
    {
      D.94294 = &this->arg1_;
      D.94295 = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>::operator()<const char*&> (D.94294, _A_1);
      D.94292 = sigc::lambda_action<sigc::bitwise<sigc::leftshift> >::do_action<std::basic_ostream<char>&, std::basic_string<char> > (D.94295, &D.88631);
      return D.94292;
    }
  finally
    {
      std::basic_string<char>::~basic_string (&D.88631);
      D.88631 = {CLOBBER};
    }
}


sigc::internal::lambda_core<T_type, false>::result_type sigc::internal::lambda_core<T_type, false>::operator()(T_arg1) const [with T_arg1 = const char*&; T_type = std::basic_string<char>; sigc::internal::lambda_core<T_type, false>::result_type = std::basic_string<char>] (const struct lambda_core * const this, const char * & D.88630)
{
  const struct basic_string * D.94302;

  D.94302 = &this->value_;
  std::basic_string<char>::basic_string (<retval>, D.94302);
  return <retval>;
}


typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1>::type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()(T_arg1) const [with T_arg1 = const char*&; T_action = sigc::bitwise<sigc::leftshift>; T_type1 = std::basic_ostringstream<char>&; T_type2 = sigc::internal::lambda_select1; typename sigc::lambda_operator<T_action, T_type1, T_type2>::deduce_result_type<T_arg1>::type = std::basic_ostream<char>&] (const struct lambda_operator * const this, const char * & _A_1)
{
  struct ostream & D.94304;
  const struct arg2_type * D.94305;
  const char * & D.94306;
  const struct lambda_core * D.94307;
  struct basic_ostringstream & D.94308;

  D.94305 = &this->arg2_;
  D.94306 = sigc::internal::lambda_select1::operator()<const char*&> (D.94305, _A_1);
  D.94307 = &this->arg1_.D.61429;
  D.94308 = sigc::internal::lambda_core<std::basic_ostringstream<char>&, false>::operator()<const char*&> (D.94307, _A_1);
  D.94304 = sigc::lambda_action<sigc::bitwise<sigc::leftshift> >::do_action<std::basic_ostringstream<char>&, const char*&> (D.94308, D.94306);
  return D.94304;
}


T_arg1 sigc::internal::lambda_select1::operator()(T_arg1) const [with T_arg1 = const char*&] (const struct lambda_select1 * const this, const char * & _A_1)
{
  const char * & D.94311;

  D.94311 = _A_1;
  return D.94311;
}


sigc::internal::lambda_core<T_type, false>::result_type sigc::internal::lambda_core<T_type, false>::operator()(T_arg1) const [with T_arg1 = const char*&; T_type = std::basic_ostringstream<char>&; sigc::internal::lambda_core<T_type, false>::result_type = std::basic_ostringstream<char>&] (const struct lambda_core * const this, const char * & D.91587)
{
  struct basic_ostringstream & D.94313;

  D.94313 = this->value_;
  return D.94313;
}


static typename sigc::lambda_action_deduce_result_type<sigc::bitwise<sigc::leftshift>, T_arg1, T_arg2>::type sigc::lambda_action<sigc::bitwise<sigc::leftshift> >::do_action(T_arg1, T_arg2) [with T_arg1 = std::basic_ostringstream<char>&; T_arg2 = const char*&; typename sigc::lambda_action_deduce_result_type<sigc::bitwise<sigc::leftshift>, T_arg1, T_arg2>::type = std::basic_ostream<char>&] (struct basic_ostringstream & _A_1, const char * & _A_2)
{
  struct ostream & D.94315;
  const char * D.94316;
  struct basic_ostream * D.94317;

  D.94316 = *_A_2;
  D.94317 = &_A_1->D.22312;
  D.94315 = std::operator<< <std::char_traits<char> > (D.94317, D.94316);
  return D.94315;
}


sigc::lambda<const T_type&> sigc::var(const T_type&) [with T_type = char [2]] (const char[2] & v)
{
  struct lambda D.94320;
  struct lambda D.86011;

  sigc::lambda<const char (&)[2]>::lambda (&D.86011, v);
  try
    {
      D.94320 = D.86011;
      return D.94320;
    }
  finally
    {
      D.86011 = {CLOBBER};
    }
}


sigc::lambda<T_type&> sigc::var(T_type&) [with T_type = std::basic_ostringstream<char>] (struct basic_ostringstream & v)
{
  struct lambda D.94323;
  struct lambda D.85978;

  sigc::lambda<std::basic_ostringstream<char>&>::lambda (&D.85978, v);
  try
    {
      D.94323 = D.85978;
      return D.94323;
    }
  finally
    {
      D.85978 = {CLOBBER};
    }
}


sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, T_arg1, typename sigc::unwrap_reference<T_arg2>::type> > sigc::operator<<(const sigc::lambda<T_type>&, const T_arg2&) [with T_arg1 = std::basic_ostringstream<char>&; T_arg2 = sigc::reference_wrapper<{anonymous}::book>; typename sigc::unwrap_reference<T_arg2>::type = {anonymous}::book&] (const struct lambda & a1, const struct reference_wrapper & a2)
{
  struct operator_type D.86055;
  struct book & D.94327;
  struct basic_ostringstream & D.94328;
  typedef struct operator_type operator_type;

  D.94327 = sigc::reference_wrapper<{anonymous}::book>::operator {anonymous}::book& (a2);
  D.94328 = a1->D.61429.value_;
  sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>::lambda_operator (&D.86055, D.94328, D.94327);
  try
    {
      sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&> >::lambda (&<retval>, &D.86055);
      return <retval>;
    }
  finally
    {
      D.86055 = {CLOBBER};
    }
}


sigc::reference_wrapper<T_type>::operator T_type&() const [with T_type = {anonymous}::book] (const struct reference_wrapper * const this)
{
  struct book & D.94332;

  D.94332 = this->value_;
  return D.94332;
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::bitwise<sigc::leftshift>; T_type1 = std::basic_ostringstream<char>&; T_type2 = {anonymous}::book&; typename sigc::type_trait<T_derived>::take = std::basic_ostringstream<char>&; typename sigc::type_trait<T_arg3>::take = {anonymous}::book&] (struct lambda_operator * const this, struct basic_ostringstream & a1, struct book & a2)
{
  struct arg1_type * D.94334;
  struct arg2_type * D.94335;

  sigc::lambda_base::lambda_base (this);
  D.94334 = &this->arg1_;
  sigc::lambda<std::basic_ostringstream<char>&>::lambda (D.94334, a1);
  D.94335 = &this->arg2_;
  sigc::lambda<{anonymous}::book&>::lambda (D.94335, a2);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = {anonymous}::book&; typename sigc::type_trait<T_base>::take = {anonymous}::book&] (struct lambda * const this, struct book & v)
{
  struct lambda_core * D.94336;

  D.94336 = &this->D.68808;
  sigc::internal::lambda_core<{anonymous}::book&, false>::lambda_core (D.94336, v);
}


sigc::internal::lambda_core<T_type, false>::lambda_core(typename sigc::type_trait<T_base>::take) [with T_type = {anonymous}::book&; typename sigc::type_trait<T_base>::take = {anonymous}::book&] (struct lambda_core * const this, struct book & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = v;
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.94337;

  D.94337 = &this->D.69617;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, true>::lambda_core (D.94337, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>] (struct lambda_core * const this, const struct lambda_operator & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, T_arg1, T_arg2> > sigc::operator<<(const sigc::lambda<T_type>&, const sigc::lambda<T_type1>&) [with T_arg1 = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>; T_arg2 = const char (&)[2]] (const struct lambda & a1, const struct lambda & a2)
{
  struct operator_type D.86077;
  const char[2] & D.94339;
  const struct lambda_operator * D.94340;
  typedef struct operator_type operator_type;

  D.94339 = a2->D.67418.value_;
  D.94340 = &a1->D.69617.value_;
  sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]>::lambda_operator (&D.86077, D.94340, D.94339);
  try
    {
      sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> >::lambda (&<retval>, &D.86077);
      return <retval>;
    }
  finally
    {
      D.86077 = {CLOBBER};
    }
}


sigc::lambda_operator<T_action, T_type1, T_type2>::lambda_operator(typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::bitwise<sigc::leftshift>; T_type1 = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>; T_type2 = const char (&)[2]; typename sigc::type_trait<T_derived>::take = const sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>&; typename sigc::type_trait<T_arg3>::take = const char (&)[2]] (struct lambda_operator * const this, const struct lambda_operator & a1, const char[2] & a2)
{
  struct arg2_type * D.94344;

  sigc::lambda_base::lambda_base (this);
  this->arg1_ = *a1;
  D.94344 = &this->arg2_;
  sigc::lambda<const char (&)[2]>::lambda (D.94344, a2);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]>; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]>&] (struct lambda * const this, const struct lambda_operator & v)
{
  struct lambda_core * D.94345;

  D.94345 = &this->D.70451;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]>, true>::lambda_core (D.94345, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]>] (struct lambda_core * const this, const struct lambda_operator & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


sigc::retype_return_functor<void, T_functor> sigc::hide_return(const T_functor&) [with T_functor = sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> >] (const struct lambda & _A_functor)
{
  sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > >::retype_return_functor (&<retval>, _A_functor);
  return <retval>;
}


sigc::retype_return_functor<void, T_functor>::retype_return_functor(typename sigc::type_trait<T_base>::take) [with T_functor = sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> >; typename sigc::type_trait<T_base>::take = const sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> >&] (struct retype_return_functor * const this, const struct lambda & _A_functor)
{
  struct adapts * D.94348;

  D.94348 = &this->D.70747;
  sigc::adapts<sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > >::adapts (D.94348, _A_functor);
}


sigc::adapts<T_functor>::adapts(const T_functor&) [with T_functor = sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> >] (struct adapts * const this, const struct lambda & _A_functor)
{
  sigc::adaptor_base::adaptor_base (this);
  this->functor_ = *_A_functor;
}


sigc::slot<T_return, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const T_functor&) [with T_functor = sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > >; T_return = void] (struct slot * const this, const struct retype_return_functor & _A_func)
{
  struct slot0 * D.94349;

  D.94349 = &this->D.68395;
  sigc::slot0<void>::slot0<sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > > > (D.94349, _A_func);
  try
    {

    }
  catch
    {
      D.94349 = &this->D.68395;
      sigc::slot0<void>::~slot0 (D.94349);
    }
}


sigc::slot0<T_return>::slot0(const T_functor&) [with T_functor = sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > >; T_return = void] (struct slot0 * const this, const struct retype_return_functor & _A_func)
{
  void * D.89000;
  struct slot_base * D.94350;
  struct rep_type * D.94351;
  void * (*<T1711>) (void *) D.94352;

  D.89000 = operator new (104);
  try
    {
      sigc::internal::typed_slot_rep<sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > > >::typed_slot_rep (D.89000, _A_func);
    }
  catch
    {
      operator delete (D.89000);
    }
  D.94350 = &this->D.68353;
  sigc::slot_base::slot_base (D.94350, D.89000);
  try
    {
      D.94351 = this->D.68353.rep_;
      D.94352 = sigc::internal::slot_call0<sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > >, void>::address ();
      D.94351->call_ = D.94352;
    }
  catch
    {
      D.94350 = &this->D.68353;
      sigc::slot_base::~slot_base (D.94350);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > >] (struct typed_slot_rep * const this, const struct retype_return_functor & functor)
{
  struct slot_rep * D.94355;
  struct adaptor_type * D.94356;
  struct slot_do_bind D.91816;

  D.94355 = &this->D.88989;
  sigc::internal::slot_rep::slot_rep (D.94355, 0B, destroy, dup);
  try
    {
      this->functor_ = *functor;
      D.94356 = &this->functor_;
      D.94355 = &this->D.88989;
      sigc::internal::slot_do_bind::slot_do_bind (&D.91816, D.94355);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > > > (&D.91816, D.94356);
        }
      finally
        {
          D.91816 = {CLOBBER};
        }
    }
  catch
    {
      D.94355 = &this->D.88989;
      sigc::internal::slot_rep::~slot_rep (D.94355);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > >] (void * data)
{
  void * D.94359;
  void * D.92356;
  struct slot_rep * a_rep;

  a_rep = data;
  D.92356 = operator new (104);
  try
    {
      sigc::internal::typed_slot_rep<sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > > >::typed_slot_rep (D.92356, a_rep);
    }
  catch
    {
      operator delete (D.92356);
    }
  D.94359 = D.92356;
  return D.94359;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > >] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.94363;
  struct slot_rep * D.94364;
  struct adaptor_type * D.94365;
  struct slot_do_bind D.92500;

  D.94363 = cl->D.88989.call_;
  D.94364 = &this->D.88989;
  sigc::internal::slot_rep::slot_rep (D.94364, D.94363, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.94365 = &this->functor_;
      D.94364 = &this->D.88989;
      sigc::internal::slot_do_bind::slot_do_bind (&D.92500, D.94364);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > > > (&D.92500, D.94365);
        }
      finally
        {
          D.92500 = {CLOBBER};
        }
    }
  catch
    {
      D.94364 = &this->D.88989;
      sigc::internal::slot_rep::~slot_rep (D.94364);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > >] (void * data)
{
  struct adaptor_type * D.94368;
  struct slot_do_unbind D.92341;
  void * D.94369;
  struct self * self_;

  self_ = data;
  self_->D.88989.call_ = 0B;
  self_->D.88989.destroy_ = 0B;
  D.94368 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.92341, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > > > (&D.92341, D.94368);
    }
  finally
    {
      D.92341 = {CLOBBER};
    }
  D.94369 = 0B;
  return D.94369;
}


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


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_unbind; T_functor = sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > >] (const struct slot_do_unbind & _A_action, const struct retype_return_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > > > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


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


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > >] (const struct limit_derived_target & _A_action, const struct retype_return_functor & _A_functor)
{
  sigc::visitor<sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::retype_return_functor<T_return, T_functor> >::do_visit_each(const T_action&, const sigc::retype_return_functor<T_return, T_functor>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_return = void; T_functor = sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> >] (const struct limit_derived_target & _A_action, const struct retype_return_functor & _A_target)
{
  struct adaptor_type * D.94373;

  D.94373 = &_A_target->D.70747.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > > (_A_action, D.94373);
}


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::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> >] (const struct limit_derived_target & _A_action, const struct lambda & _A_functor)
{
  sigc::visitor<sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::lambda<T_type> >::do_visit_each(const T_action&, const sigc::lambda<T_type>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_type = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]>] (const struct limit_derived_target & _A_action, const struct lambda & _A_target)
{
  const struct lambda_operator * D.94374;

  D.94374 = &_A_target->D.70451.value_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > (_A_action, D.94374);
}


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::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]>] (const struct limit_derived_target & _A_action, const struct lambda_operator & _A_functor)
{
  sigc::visitor<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::lambda_operator<T_lambda_action, T_arg1, T_arg2> >::do_visit_each(const T_action&, const sigc::lambda_operator<T_lambda_action, T_arg1, T_arg2>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_lambda_action = sigc::bitwise<sigc::leftshift>; T_arg1 = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>; T_arg2 = const char (&)[2]] (const struct limit_derived_target & _A_action, const struct lambda_operator & _A_target)
{
  const struct arg1_type * D.94375;
  const struct arg2_type * D.94376;

  D.94375 = &_A_target->arg1_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&> > (_A_action, D.94375);
  D.94376 = &_A_target->arg2_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::lambda<const char (&)[2]> > (_A_action, D.94376);
}


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::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>] (const struct limit_derived_target & _A_action, const struct lambda_operator & _A_functor)
{
  sigc::visitor<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::lambda_operator<T_lambda_action, T_arg1, T_arg2> >::do_visit_each(const T_action&, const sigc::lambda_operator<T_lambda_action, T_arg1, T_arg2>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_lambda_action = sigc::bitwise<sigc::leftshift>; T_arg1 = std::basic_ostringstream<char>&; T_arg2 = {anonymous}::book&] (const struct limit_derived_target & _A_action, const struct lambda_operator & _A_target)
{
  const struct arg1_type * D.94377;
  const struct arg2_type * D.94378;

  D.94377 = &_A_target->arg1_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::lambda<std::basic_ostringstream<char>&> > (_A_action, D.94377);
  D.94378 = &_A_target->arg2_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::lambda<{anonymous}::book&> > (_A_action, D.94378);
}


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


static void sigc::visitor<sigc::lambda<T_type> >::do_visit_each(const T_action&, const sigc::lambda<T_type>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_type = std::basic_ostringstream<char>&] (const struct limit_derived_target & _A_action, const struct lambda & _A_target)
{
  struct basic_ostringstream & D.94379;

  D.94379 = _A_target->D.61429.value_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, std::basic_ostringstream<char> > (_A_action, D.94379);
}


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


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


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


static void sigc::visitor<sigc::lambda<T_type> >::do_visit_each(const T_action&, const sigc::lambda<T_type>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_type = {anonymous}::book&] (const struct limit_derived_target & _A_action, const struct lambda & _A_target)
{
  struct book & D.94380;

  D.94380 = _A_target->D.68808.value_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, {anonymous}::book> (_A_action, D.94380);
}


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


void sigc::internal::limit_derived_target<T_target*, T_action>::operator()(const T_type&) const [with T_type = {anonymous}::book; T_target = sigc::trackable; T_action = sigc::internal::slot_do_unbind] (const struct limit_derived_target * const this, const struct book & _A_type)
{
  sigc::internal::with_type_pointer<true, {anonymous}::book, 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 = {anonymous}::book; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>] (const struct book & _A_type, const struct limit_derived_target & _A_action)
{
  const struct trackable * D.94381;
  const struct slot_do_unbind * D.94382;

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


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

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


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


static void sigc::visitor<sigc::lambda<T_type> >::do_visit_each(const T_action&, const sigc::lambda<T_type>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_type = const char (&)[2]] (const struct limit_derived_target & _A_action, const struct lambda & _A_target)
{
  const char[2] & D.94384;

  D.94384 = _A_target->D.67418.value_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, char [2]> (_A_action, D.94384);
}


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


void sigc::internal::limit_derived_target<T_target*, T_action>::operator()(const T_type&) const [with T_type = char [2]; T_target = sigc::trackable; T_action = sigc::internal::slot_do_unbind] (const struct limit_derived_target * const this, const char[2] & _A_type)
{
  sigc::internal::with_type_pointer<false, char [2], 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 = char [2]; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>] (const char[2] & D.93096, const struct limit_derived_target & D.93097)
{
  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.94385;

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


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


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_bind; T_functor = sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > >] (const struct slot_do_bind & _A_action, const struct retype_return_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > > > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


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


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > >] (const struct limit_derived_target & _A_action, const struct retype_return_functor & _A_functor)
{
  sigc::visitor<sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::retype_return_functor<T_return, T_functor> >::do_visit_each(const T_action&, const sigc::retype_return_functor<T_return, T_functor>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_return = void; T_functor = sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> >] (const struct limit_derived_target & _A_action, const struct retype_return_functor & _A_target)
{
  struct adaptor_type * D.94387;

  D.94387 = &_A_target->D.70747.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > > (_A_action, D.94387);
}


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::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> >] (const struct limit_derived_target & _A_action, const struct lambda & _A_functor)
{
  sigc::visitor<sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::lambda<T_type> >::do_visit_each(const T_action&, const sigc::lambda<T_type>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_type = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]>] (const struct limit_derived_target & _A_action, const struct lambda & _A_target)
{
  const struct lambda_operator * D.94388;

  D.94388 = &_A_target->D.70451.value_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > (_A_action, D.94388);
}


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::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]>] (const struct limit_derived_target & _A_action, const struct lambda_operator & _A_functor)
{
  sigc::visitor<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::lambda_operator<T_lambda_action, T_arg1, T_arg2> >::do_visit_each(const T_action&, const sigc::lambda_operator<T_lambda_action, T_arg1, T_arg2>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_lambda_action = sigc::bitwise<sigc::leftshift>; T_arg1 = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>; T_arg2 = const char (&)[2]] (const struct limit_derived_target & _A_action, const struct lambda_operator & _A_target)
{
  const struct arg1_type * D.94389;
  const struct arg2_type * D.94390;

  D.94389 = &_A_target->arg1_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&> > (_A_action, D.94389);
  D.94390 = &_A_target->arg2_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::lambda<const char (&)[2]> > (_A_action, D.94390);
}


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::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>] (const struct limit_derived_target & _A_action, const struct lambda_operator & _A_functor)
{
  sigc::visitor<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::lambda_operator<T_lambda_action, T_arg1, T_arg2> >::do_visit_each(const T_action&, const sigc::lambda_operator<T_lambda_action, T_arg1, T_arg2>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_lambda_action = sigc::bitwise<sigc::leftshift>; T_arg1 = std::basic_ostringstream<char>&; T_arg2 = {anonymous}::book&] (const struct limit_derived_target & _A_action, const struct lambda_operator & _A_target)
{
  const struct arg1_type * D.94391;
  const struct arg2_type * D.94392;

  D.94391 = &_A_target->arg1_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::lambda<std::basic_ostringstream<char>&> > (_A_action, D.94391);
  D.94392 = &_A_target->arg2_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::lambda<{anonymous}::book&> > (_A_action, D.94392);
}


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


static void sigc::visitor<sigc::lambda<T_type> >::do_visit_each(const T_action&, const sigc::lambda<T_type>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_type = std::basic_ostringstream<char>&] (const struct limit_derived_target & _A_action, const struct lambda & _A_target)
{
  struct basic_ostringstream & D.94393;

  D.94393 = _A_target->D.61429.value_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, std::basic_ostringstream<char> > (_A_action, D.94393);
}


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


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


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


static void sigc::visitor<sigc::lambda<T_type> >::do_visit_each(const T_action&, const sigc::lambda<T_type>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_type = {anonymous}::book&] (const struct limit_derived_target & _A_action, const struct lambda & _A_target)
{
  struct book & D.94394;

  D.94394 = _A_target->D.68808.value_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, {anonymous}::book> (_A_action, D.94394);
}


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


void sigc::internal::limit_derived_target<T_target*, T_action>::operator()(const T_type&) const [with T_type = {anonymous}::book; T_target = sigc::trackable; T_action = sigc::internal::slot_do_bind] (const struct limit_derived_target * const this, const struct book & _A_type)
{
  sigc::internal::with_type_pointer<true, {anonymous}::book, 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 = {anonymous}::book; T_limit = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>] (const struct book & _A_type, const struct limit_derived_target & _A_action)
{
  const struct trackable * D.94395;
  const struct slot_do_bind * D.94396;

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


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

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


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


static void sigc::visitor<sigc::lambda<T_type> >::do_visit_each(const T_action&, const sigc::lambda<T_type>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_type = const char (&)[2]] (const struct limit_derived_target & _A_action, const struct lambda & _A_target)
{
  const char[2] & D.94398;

  D.94398 = _A_target->D.67418.value_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, char [2]> (_A_action, D.94398);
}


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


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


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

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


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

  D.94402 = this->destroy_;
  if (D.94402 != 0B) goto <D.94403>; else goto <D.94404>;
  <D.94403>:
  D.94402 = this->destroy_;
  D.94402 (this);
  goto <D.94405>;
  <D.94404>:
  <D.94405>:
}


static void* (* sigc::internal::slot_call0<T_functor, T_return>::address())(void*) [with T_functor = sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > >; T_return = void; sigc::internal::hook = void* (*)(void*)] ()
{
  void * (*hook) (void *) D.94406;

  D.94406 = call_it;
  return D.94406;
}


static T_return sigc::internal::slot_call0<T_functor, T_return>::call_it(sigc::internal::slot_rep*) [with T_functor = sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > >; T_return = void] (struct slot_rep * rep)
{
  struct adaptor_type * D.94408;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.94408 = &typed_rep->functor_;
  sigc::retype_return_functor<void, sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> > >::operator() (D.94408);
  return;
}


void sigc::retype_return_functor<void, T_functor>::operator()() [with T_functor = sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]> >] (struct retype_return_functor * const this)
{
  struct lambda_core * D.94410;

  D.94410 = &this->D.70747.functor_.D.70451;
  sigc::internal::lambda_core<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]>, true>::operator() (D.94410);
}


sigc::internal::lambda_core<T_type, true>::result_type sigc::internal::lambda_core<T_type, true>::operator()() const [with T_type = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]>; sigc::internal::lambda_core<T_type, true>::result_type = std::basic_ostream<char>&] (const struct lambda_core * const this)
{
  struct ostream & D.94411;
  const struct lambda_operator * D.94412;

  D.94412 = &this->value_;
  D.94411 = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>, const char (&)[2]>::operator() (D.94412);
  return D.94411;
}


sigc::lambda_operator<T_action, T_type1, T_type2>::result_type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()() const [with T_action = sigc::bitwise<sigc::leftshift>; T_type1 = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>; T_type2 = const char (&)[2]; sigc::lambda_operator<T_action, T_type1, T_type2>::result_type = std::basic_ostream<char>&] (const struct lambda_operator * const this)
{
  struct ostream & D.94415;
  const struct lambda_core * D.94416;
  const char[2] & D.94417;
  const struct arg1_type * D.94418;
  struct ostream & D.94419;

  D.94416 = &this->arg2_.D.67418;
  D.94417 = sigc::internal::lambda_core<const char (&)[2], false>::operator() (D.94416);
  D.94418 = &this->arg1_;
  D.94419 = sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, {anonymous}::book&>::operator() (D.94418);
  D.94415 = sigc::lambda_action<sigc::bitwise<sigc::leftshift> >::do_action<std::basic_ostream<char>&, const char (&)[2]> (D.94419, D.94417);
  return D.94415;
}


sigc::lambda_operator<T_action, T_type1, T_type2>::result_type sigc::lambda_operator<T_action, T_type1, T_type2>::operator()() const [with T_action = sigc::bitwise<sigc::leftshift>; T_type1 = std::basic_ostringstream<char>&; T_type2 = {anonymous}::book&; sigc::lambda_operator<T_action, T_type1, T_type2>::result_type = std::basic_ostream<char>&] (const struct lambda_operator * const this)
{
  struct ostream & D.94423;
  const struct lambda_core * D.94424;
  struct book & D.94425;
  const struct lambda_core * D.94426;
  struct basic_ostringstream & D.94427;

  D.94424 = &this->arg2_.D.68808;
  D.94425 = sigc::internal::lambda_core<{anonymous}::book&, false>::operator() (D.94424);
  D.94426 = &this->arg1_.D.61429;
  D.94427 = sigc::internal::lambda_core<std::basic_ostringstream<char>&, false>::operator() (D.94426);
  D.94423 = sigc::lambda_action<sigc::bitwise<sigc::leftshift> >::do_action<std::basic_ostringstream<char>&, {anonymous}::book&> (D.94427, D.94425);
  return D.94423;
}


sigc::internal::lambda_core<T_type, false>::result_type sigc::internal::lambda_core<T_type, false>::operator()() const [with T_type = {anonymous}::book&; sigc::internal::lambda_core<T_type, false>::result_type = {anonymous}::book&] (const struct lambda_core * const this)
{
  struct book & D.94430;

  D.94430 = this->value_;
  return D.94430;
}


static typename sigc::lambda_action_deduce_result_type<sigc::bitwise<sigc::leftshift>, T_arg1, T_arg2>::type sigc::lambda_action<sigc::bitwise<sigc::leftshift> >::do_action(T_arg1, T_arg2) [with T_arg1 = std::basic_ostringstream<char>&; T_arg2 = {anonymous}::book&; typename sigc::lambda_action_deduce_result_type<sigc::bitwise<sigc::leftshift>, T_arg1, T_arg2>::type = std::basic_ostream<char>&] (struct basic_ostringstream & _A_1, struct book & _A_2)
{
  struct ostream & D.94432;
  struct ostringstream & D.94433;

  D.94433 = {anonymous}::operator<< (_A_1, _A_2);
  D.94432 = &D.94433->D.22312;
  return D.94432;
}


std::ostringstream& {anonymous}::operator<<(std::ostringstream&, const {anonymous}::book&) (struct ostringstream & s, const struct book & b)
{
  const struct string * D.94436;
  struct basic_ostream * D.94437;
  struct ostringstream & D.94438;

  D.94436 = &b->name_;
  D.94437 = &s->D.22312;
  std::operator<< <char, std::char_traits<char>, std::allocator<char> > (D.94437, D.94436);
  D.94438 = s;
  return D.94438;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2) const [with T_arg1 = int; T_arg2 = int; T_type = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> >; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct lambda_core * const this, int _A_1, int _A_2)
{
  type D.94440;
  const struct lambda_group2 * D.94441;

  D.94441 = &this->value_;
  D.94440 = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> >::operator()<int&, int&> (D.94441, &_A_1, &_A_2);
  return D.94440;
}


typename sigc::lambda_group2<T_functor, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type sigc::lambda_group2<T_functor, T_type1, T_type2>::operator()(T_arg1, T_arg2) const [with T_arg1 = int&; T_arg2 = int&; T_functor = int (*)(int, int); T_type1 = sigc::lambda<sigc::internal::lambda_select1>; T_type2 = sigc::lambda<sigc::internal::lambda_select2>; typename sigc::lambda_group2<T_functor, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct lambda_group2 * const this, int & _A_1, int & _A_2)
{
  type D.94444;
  const struct lambda_core * D.94445;
  int & D.94446;
  const struct lambda_core * D.94447;
  int & D.94448;
  struct functor_type * D.94449;

  D.94445 = &this->value2_.D.40511;
  D.94446 = sigc::internal::lambda_core<sigc::internal::lambda_select2, true>::operator()<int&, int&> (D.94445, _A_1, _A_2);
  D.94447 = &this->value1_.D.40074;
  D.94448 = sigc::internal::lambda_core<sigc::internal::lambda_select1, true>::operator()<int&, int&> (D.94447, _A_1, _A_2);
  D.94449 = &this->func_;
  D.94444 = sigc::adaptor_functor<sigc::pointer_functor2<int, int, int> >::operator()<int&, int&> (D.94449, D.94448, D.94446);
  return D.94444;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2) const [with T_arg1 = int&; T_arg2 = int&; T_type = sigc::internal::lambda_select2; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type = int&] (const struct lambda_core * const this, int & _A_1, int & _A_2)
{
  int & D.94452;
  const struct lambda_select2 * D.94453;

  D.94453 = &this->value_;
  D.94452 = sigc::internal::lambda_select2::operator()<int&, int&> (D.94453, _A_1, _A_2);
  return D.94452;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2) const [with T_arg1 = int&; T_arg2 = int&; T_type = sigc::internal::lambda_select1; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type = int&] (const struct lambda_core * const this, int & _A_1, int & _A_2)
{
  int & D.94455;
  const struct lambda_select1 * D.94456;

  D.94456 = &this->value_;
  D.94455 = sigc::internal::lambda_select1::operator()<int&, int&> (D.94456, _A_1, _A_2);
  return D.94455;
}


typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1, T_arg2>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1, T_arg2) const [with T_arg1 = int&; T_arg2 = int&; T_functor = sigc::pointer_functor2<int, int, int>; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct adaptor_functor * const this, int & _A_arg1, int & _A_arg2)
{
  type D.94458;
  struct pointer_functor2 * D.94459;

  D.94459 = &this->functor_;
  D.94458 = sigc::pointer_functor2<int, int, int>::operator() (D.94459, _A_arg1, _A_arg2);
  return D.94458;
}


T_return sigc::pointer_functor2<T_arg1, T_arg2, T_return>::operator()(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take) const [with T_arg1 = int; T_arg2 = int; T_return = int; typename sigc::type_trait<T_base>::take = const int&; typename sigc::type_trait<T_derived>::take = const int&] (const struct pointer_functor2 * const this, const int & _A_a1, const int & _A_a2)
{
  int D.94462;
  int (*<Tdd0b>) (int, int) D.94463;
  int D.94464;
  int D.94465;

  D.94463 = this->func_ptr_;
  D.94464 = *_A_a2;
  D.94465 = *_A_a1;
  D.94462 = D.94463 (D.94465, D.94464);
  return D.94462;
}


sigc::lambda<sigc::lambda_group2<T_functor, typename sigc::unwrap_reference<T_arg2>::type, typename sigc::unwrap_reference<T_type2>::type> > sigc::group(const T_functor&, T_type1, T_type2) [with T_functor = int (*)(int, int); T_type1 = sigc::lambda<sigc::internal::lambda_select2>; T_type2 = sigc::lambda<sigc::internal::lambda_select1>; typename sigc::unwrap_reference<T_type2>::type = sigc::lambda<sigc::internal::lambda_select1>; typename sigc::unwrap_reference<T_arg2>::type = sigc::lambda<sigc::internal::lambda_select2>] (int (*<Tdd0e>) (int, int) & _A_func, struct lambda _A_1, struct lambda _A_2)
{
  struct T_lambda D.86235;
  typedef struct T_lambda T_lambda;

  sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select2>, sigc::lambda<sigc::internal::lambda_select1> >::lambda_group2 (&D.86235, _A_func, &_A_1, &_A_2);
  try
    {
      sigc::lambda<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select2>, sigc::lambda<sigc::internal::lambda_select1> > >::lambda (&<retval>, &D.86235);
      return <retval>;
    }
  finally
    {
      D.86235 = {CLOBBER};
    }
}


sigc::lambda_group2<T_functor, T_type1, T_type2>::lambda_group2(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_functor = int (*)(int, int); T_type1 = sigc::lambda<sigc::internal::lambda_select2>; T_type2 = sigc::lambda<sigc::internal::lambda_select1>; typename sigc::type_trait<T_base>::take = int (* const&)(int, int); typename sigc::type_trait<T_derived>::take = const sigc::lambda<sigc::internal::lambda_select2>&; typename sigc::type_trait<T_arg3>::take = const sigc::lambda<sigc::internal::lambda_select1>&] (struct lambda_group2 * const this, int (*<Tdd0e>) (int, int) & _A_func, const struct lambda & _A_1, const struct lambda & _A_2)
{
  struct functor_type * D.94472;

  sigc::lambda_base::lambda_base (this);
  D.94472 = &this->func_;
  sigc::adaptor_functor<sigc::pointer_functor2<int, int, int> >::adaptor_functor<int (*)(int, int)> (D.94472, _A_func);
}


sigc::adaptor_functor<T_functor>::adaptor_functor(const T_type&) [with T_type = int (*)(int, int); T_functor = sigc::pointer_functor2<int, int, int>] (struct adaptor_functor * const this, int (*<Tdd0e>) (int, int) & _A_type)
{
  int (*<Tdd0b>) (int, int) D.94473;
  struct pointer_functor2 * D.94474;

  sigc::adaptor_base::adaptor_base (this);
  D.94473 = *_A_type;
  D.94474 = &this->functor_;
  sigc::pointer_functor2<int, int, int>::pointer_functor2 (D.94474, D.94473);
}


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


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select2>, sigc::lambda<sigc::internal::lambda_select1> >; typename sigc::type_trait<T_base>::take = const sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select2>, sigc::lambda<sigc::internal::lambda_select1> >&] (struct lambda * const this, const struct lambda_group2 & v)
{
  struct lambda_core * D.94475;

  D.94475 = &this->D.73514;
  sigc::internal::lambda_core<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select2>, sigc::lambda<sigc::internal::lambda_select1> >, true>::lambda_core (D.94475, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select2>, sigc::lambda<sigc::internal::lambda_select1> >] (struct lambda_core * const this, const struct lambda_group2 & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2) const [with T_arg1 = int; T_arg2 = int; T_type = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select2>, sigc::lambda<sigc::internal::lambda_select1> >; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct lambda_core * const this, int _A_1, int _A_2)
{
  type D.94476;
  const struct lambda_group2 * D.94477;

  D.94477 = &this->value_;
  D.94476 = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select2>, sigc::lambda<sigc::internal::lambda_select1> >::operator()<int&, int&> (D.94477, &_A_1, &_A_2);
  return D.94476;
}


typename sigc::lambda_group2<T_functor, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type sigc::lambda_group2<T_functor, T_type1, T_type2>::operator()(T_arg1, T_arg2) const [with T_arg1 = int&; T_arg2 = int&; T_functor = int (*)(int, int); T_type1 = sigc::lambda<sigc::internal::lambda_select2>; T_type2 = sigc::lambda<sigc::internal::lambda_select1>; typename sigc::lambda_group2<T_functor, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct lambda_group2 * const this, int & _A_1, int & _A_2)
{
  type D.94480;
  const struct lambda_core * D.94481;
  int & D.94482;
  const struct lambda_core * D.94483;
  int & D.94484;
  struct functor_type * D.94485;

  D.94481 = &this->value2_.D.40074;
  D.94482 = sigc::internal::lambda_core<sigc::internal::lambda_select1, true>::operator()<int&, int&> (D.94481, _A_1, _A_2);
  D.94483 = &this->value1_.D.40511;
  D.94484 = sigc::internal::lambda_core<sigc::internal::lambda_select2, true>::operator()<int&, int&> (D.94483, _A_1, _A_2);
  D.94485 = &this->func_;
  D.94480 = sigc::adaptor_functor<sigc::pointer_functor2<int, int, int> >::operator()<int&, int&> (D.94485, D.94484, D.94482);
  return D.94480;
}


sigc::reference_wrapper<T_type> sigc::ref(T_type&) [with T_type = {anonymous}::bar] (struct bar & v)
{
  struct reference_wrapper D.94488;
  struct reference_wrapper D.86387;

  sigc::reference_wrapper<{anonymous}::bar>::reference_wrapper (&D.86387, v);
  try
    {
      D.94488 = D.86387;
      return D.94488;
    }
  finally
    {
      D.86387 = {CLOBBER};
    }
}


sigc::reference_wrapper<T_type>::reference_wrapper(T_type&) [with T_type = {anonymous}::bar] (struct reference_wrapper * const this, struct bar & v)
{
  this->value_ = v;
}


sigc::mem_functor2<T_return, T_obj, T_arg1, T_arg2> sigc::mem_fun(T_return (T_obj::*)(T_arg1, T_arg2)) [with T_arg1 = int; T_arg2 = int; T_return = int; T_obj = {anonymous}::bar] (struct 
{
  int bar::<T729a> (struct bar *, int, int) * __pfn;
  long int __delta;
} _A_func)
{
  struct mem_functor2 D.94491;
  struct mem_functor2 D.86363;

  sigc::mem_functor2<int, {anonymous}::bar, int, int>::mem_functor2 (&D.86363, _A_func);
  try
    {
      D.94491 = D.86363;
      return D.94491;
    }
  finally
    {
      D.86363 = {CLOBBER};
    }
}


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


sigc::lambda<sigc::lambda_group3<T_functor, typename sigc::unwrap_reference<T_arg2>::type, typename sigc::unwrap_reference<T_type2>::type, typename sigc::unwrap_reference<T_type3>::type> > sigc::group(const T_functor&, T_type1, T_type2, T_type3) [with T_functor = sigc::mem_functor2<int, {anonymous}::bar, int, int>; T_type1 = sigc::lambda<sigc::internal::lambda_select1>; T_type2 = sigc::lambda<sigc::internal::lambda_select2>; T_type3 = sigc::lambda<sigc::internal::lambda_select3>; typename sigc::unwrap_reference<T_type3>::type = sigc::lambda<sigc::internal::lambda_select3>; typename sigc::unwrap_reference<T_type2>::type = sigc::lambda<sigc::internal::lambda_select2>; typename sigc::unwrap_reference<T_arg2>::type = sigc::lambda<sigc::internal::lambda_select1>] (const struct mem_functor2 & _A_func, struct lambda _A_1, struct lambda _A_2, struct lambda _A_3)
{
  struct T_lambda D.86375;
  typedef struct T_lambda T_lambda;

  sigc::lambda_group3<sigc::mem_functor2<int, {anonymous}::bar, int, int>, sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2>, sigc::lambda<sigc::internal::lambda_select3> >::lambda_group3 (&D.86375, _A_func, &_A_1, &_A_2, &_A_3);
  try
    {
      sigc::lambda<sigc::lambda_group3<sigc::mem_functor2<int, {anonymous}::bar, int, int>, sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2>, sigc::lambda<sigc::internal::lambda_select3> > >::lambda (&<retval>, &D.86375);
      return <retval>;
    }
  finally
    {
      D.86375 = {CLOBBER};
    }
}


sigc::lambda_group3<T_functor, T_type1, T_type2, T_type3>::lambda_group3(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take, typename sigc::type_trait<T_arg4>::take) [with T_functor = sigc::mem_functor2<int, {anonymous}::bar, int, int>; T_type1 = sigc::lambda<sigc::internal::lambda_select1>; T_type2 = sigc::lambda<sigc::internal::lambda_select2>; T_type3 = sigc::lambda<sigc::internal::lambda_select3>; typename sigc::type_trait<T_base>::take = const sigc::mem_functor2<int, {anonymous}::bar, int, int>&; typename sigc::type_trait<T_derived>::take = const sigc::lambda<sigc::internal::lambda_select1>&; typename sigc::type_trait<T_arg3>::take = const sigc::lambda<sigc::internal::lambda_select2>&; typename sigc::type_trait<T_arg4>::take = const sigc::lambda<sigc::internal::lambda_select3>&] (struct lambda_group3 * const this, const struct mem_functor2 & _A_func, const struct lambda & _A_1, const struct lambda & _A_2, const struct lambda & _A_3)
{
  struct functor_type * D.94498;

  sigc::lambda_base::lambda_base (this);
  D.94498 = &this->func_;
  sigc::adaptor_functor<sigc::mem_functor2<int, {anonymous}::bar, int, int> >::adaptor_functor (D.94498, _A_func);
}


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


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_group3<sigc::mem_functor2<int, {anonymous}::bar, int, int>, sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2>, sigc::lambda<sigc::internal::lambda_select3> >; typename sigc::type_trait<T_base>::take = const sigc::lambda_group3<sigc::mem_functor2<int, {anonymous}::bar, int, int>, sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2>, sigc::lambda<sigc::internal::lambda_select3> >&] (struct lambda * const this, const struct lambda_group3 & v)
{
  struct lambda_core * D.94499;

  D.94499 = &this->D.75326;
  sigc::internal::lambda_core<sigc::lambda_group3<sigc::mem_functor2<int, {anonymous}::bar, int, int>, sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2>, sigc::lambda<sigc::internal::lambda_select3> >, true>::lambda_core (D.94499, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_group3<sigc::mem_functor2<int, {anonymous}::bar, int, int>, sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2>, sigc::lambda<sigc::internal::lambda_select3> >] (struct lambda_core * const this, const struct lambda_group3 & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2, T_arg3) const [with T_arg1 = sigc::reference_wrapper<{anonymous}::bar>; T_arg2 = int; T_arg3 = int; T_type = sigc::lambda_group3<sigc::mem_functor2<int, {anonymous}::bar, int, int>, sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2>, sigc::lambda<sigc::internal::lambda_select3> >; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type = int] (const struct lambda_core * const this, struct reference_wrapper _A_1, int _A_2, int _A_3)
{
  type D.94500;
  const struct lambda_group3 * D.94501;

  D.94501 = &this->value_;
  D.94500 = sigc::lambda_group3<sigc::mem_functor2<int, {anonymous}::bar, int, int>, sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2>, sigc::lambda<sigc::internal::lambda_select3> >::operator()<sigc::reference_wrapper<{anonymous}::bar>&, int&, int&> (D.94501, &_A_1, &_A_2, &_A_3);
  return D.94500;
}


typename sigc::lambda_group3<T_functor, T_type1, T_type2, T_type3>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type sigc::lambda_group3<T_functor, T_type1, T_type2, T_type3>::operator()(T_arg1, T_arg2, T_arg3) const [with T_arg1 = sigc::reference_wrapper<{anonymous}::bar>&; T_arg2 = int&; T_arg3 = int&; T_functor = sigc::mem_functor2<int, {anonymous}::bar, int, int>; T_type1 = sigc::lambda<sigc::internal::lambda_select1>; T_type2 = sigc::lambda<sigc::internal::lambda_select2>; T_type3 = sigc::lambda<sigc::internal::lambda_select3>; typename sigc::lambda_group3<T_functor, T_type1, T_type2, T_type3>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type = int] (const struct lambda_group3 * const this, struct reference_wrapper & _A_1, int & _A_2, int & _A_3)
{
  type D.94504;
  const struct lambda_core * D.94505;
  int & D.94506;
  const struct lambda_core * D.94507;
  int & D.94508;
  const struct lambda_core * D.94509;
  struct reference_wrapper & D.94510;
  struct functor_type * D.94511;

  D.94505 = &this->value3_.D.45646;
  D.94506 = sigc::internal::lambda_core<sigc::internal::lambda_select3, true>::operator()<sigc::reference_wrapper<{anonymous}::bar>&, int&, int&> (D.94505, _A_1, _A_2, _A_3);
  D.94507 = &this->value2_.D.40511;
  D.94508 = sigc::internal::lambda_core<sigc::internal::lambda_select2, true>::operator()<sigc::reference_wrapper<{anonymous}::bar>&, int&, int&> (D.94507, _A_1, _A_2, _A_3);
  D.94509 = &this->value1_.D.40074;
  D.94510 = sigc::internal::lambda_core<sigc::internal::lambda_select1, true>::operator()<sigc::reference_wrapper<{anonymous}::bar>&, int&, int&> (D.94509, _A_1, _A_2, _A_3);
  D.94511 = &this->func_;
  D.94504 = sigc::adaptor_functor<sigc::mem_functor2<int, {anonymous}::bar, int, int> >::operator()<sigc::reference_wrapper<{anonymous}::bar>&, int&, int&> (D.94511, D.94510, D.94508, D.94506);
  return D.94504;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2, T_arg3) const [with T_arg1 = sigc::reference_wrapper<{anonymous}::bar>&; T_arg2 = int&; T_arg3 = int&; T_type = sigc::internal::lambda_select3; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type = int&] (const struct lambda_core * const this, struct reference_wrapper & _A_1, int & _A_2, int & _A_3)
{
  int & D.94517;
  const struct lambda_select3 * D.94518;

  D.94518 = &this->value_;
  D.94517 = sigc::internal::lambda_select3::operator()<sigc::reference_wrapper<{anonymous}::bar>&, int&, int&> (D.94518, _A_1, _A_2, _A_3);
  return D.94517;
}


T_arg3 sigc::internal::lambda_select3::operator()(T_arg1, T_arg2, T_arg3) const [with T_arg1 = sigc::reference_wrapper<{anonymous}::bar>&; T_arg2 = int&; T_arg3 = int&] (const struct lambda_select3 * const this, struct reference_wrapper & D.91908, int & D.91909, int & _A_3)
{
  int & D.94520;

  D.94520 = _A_3;
  return D.94520;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2, T_arg3) const [with T_arg1 = sigc::reference_wrapper<{anonymous}::bar>&; T_arg2 = int&; T_arg3 = int&; T_type = sigc::internal::lambda_select2; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type = int&] (const struct lambda_core * const this, struct reference_wrapper & _A_1, int & _A_2, int & _A_3)
{
  int & D.94522;
  const struct lambda_select2 * D.94523;

  D.94523 = &this->value_;
  D.94522 = sigc::internal::lambda_select2::operator()<sigc::reference_wrapper<{anonymous}::bar>&, int&, int&> (D.94523, _A_1, _A_2, _A_3);
  return D.94522;
}


T_arg2 sigc::internal::lambda_select2::operator()(T_arg1, T_arg2, T_arg3) const [with T_arg1 = sigc::reference_wrapper<{anonymous}::bar>&; T_arg2 = int&; T_arg3 = int&] (const struct lambda_select2 * const this, struct reference_wrapper & D.91902, int & _A_2, int & D.91904)
{
  int & D.94525;

  D.94525 = _A_2;
  return D.94525;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2, T_arg3) const [with T_arg1 = sigc::reference_wrapper<{anonymous}::bar>&; T_arg2 = int&; T_arg3 = int&; T_type = sigc::internal::lambda_select1; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type = sigc::reference_wrapper<{anonymous}::bar>&] (const struct lambda_core * const this, struct reference_wrapper & _A_1, int & _A_2, int & _A_3)
{
  struct reference_wrapper & D.94527;
  const struct lambda_select1 * D.94528;

  D.94528 = &this->value_;
  D.94527 = sigc::internal::lambda_select1::operator()<sigc::reference_wrapper<{anonymous}::bar>&, int&, int&> (D.94528, _A_1, _A_2, _A_3);
  return D.94527;
}


T_arg1 sigc::internal::lambda_select1::operator()(T_arg1, T_arg2, T_arg3) const [with T_arg1 = sigc::reference_wrapper<{anonymous}::bar>&; T_arg2 = int&; T_arg3 = int&] (const struct lambda_select1 * const this, struct reference_wrapper & _A_1, int & D.91897, int & D.91898)
{
  struct reference_wrapper & D.94530;

  D.94530 = _A_1;
  return D.94530;
}


typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1, T_arg2, T_arg3) const [with T_arg1 = sigc::reference_wrapper<{anonymous}::bar>&; T_arg2 = int&; T_arg3 = int&; T_functor = sigc::mem_functor2<int, {anonymous}::bar, int, int>; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type = int] (const struct adaptor_functor * const this, struct reference_wrapper & _A_arg1, int & _A_arg2, int & _A_arg3)
{
  type D.94532;
  struct bar & D.94533;
  struct mem_functor2 * D.94534;

  D.94533 = sigc::reference_wrapper<{anonymous}::bar>::operator {anonymous}::bar& (_A_arg1);
  D.94534 = &this->functor_;
  D.94532 = sigc::mem_functor2<int, {anonymous}::bar, int, int>::operator() (D.94534, D.94533, _A_arg2, _A_arg3);
  return D.94532;
}


sigc::reference_wrapper<T_type>::operator T_type&() const [with T_type = {anonymous}::bar] (const struct reference_wrapper * const this)
{
  struct bar & D.94537;

  D.94537 = this->value_;
  return D.94537;
}


T_return sigc::mem_functor2<T_arg1, T_arg2, T_return, T_obj>::operator()(T_obj&, typename sigc::type_trait<T_arg3>::take, typename sigc::type_trait<T_arg4>::take) const [with T_return = int; T_obj = {anonymous}::bar; T_arg1 = int; T_arg2 = int; typename sigc::type_trait<T_arg3>::take = const int&; typename sigc::type_trait<T_arg4>::take = const int&] (const struct mem_functor2 * const this, struct bar & _A_obj, const int & _A_a1, const int & _A_a2)
{
  int D.94539;
  int bar::<T729a> (struct bar *, int, int) * iftmp.8;
  int bar::<T729a> (struct bar *, int, int) * D.94541;
  long int D.94542;
  long int D.94543;
  long int D.94547;
  sizetype D.94548;
  struct bar * D.94549;
  int (*__vtbl_ptr_type) () * D.94550;
  long int D.94551;
  sizetype D.94552;
  int (*__vtbl_ptr_type) () * D.94553;
  int D.94554;
  int D.94555;

  D.94541 = this->func_ptr_.__pfn;
  D.94542 = (long int) D.94541;
  D.94543 = D.94542 & 1;
  if (D.94543 == 0) goto <D.94544>; else goto <D.94545>;
  <D.94544>:
  iftmp.8 = this->func_ptr_.__pfn;
  goto <D.94546>;
  <D.94545>:
  D.94547 = this->func_ptr_.__delta;
  D.94548 = (sizetype) D.94547;
  D.94549 = _A_obj + D.94548;
  D.94550 = MEM[(int (*__vtbl_ptr_type) () * *)D.94549];
  D.94541 = this->func_ptr_.__pfn;
  D.94542 = (long int) D.94541;
  D.94551 = D.94542 + -1;
  D.94552 = (sizetype) D.94551;
  D.94553 = D.94550 + D.94552;
  iftmp.8 = *D.94553;
  <D.94546>:
  D.94554 = *_A_a2;
  D.94555 = *_A_a1;
  D.94547 = this->func_ptr_.__delta;
  D.94548 = (sizetype) D.94547;
  D.94549 = _A_obj + D.94548;
  D.94539 = iftmp.8 (D.94549, D.94555, D.94554);
  return D.94539;
}


sigc::lambda<sigc::lambda_group2<T_functor, typename sigc::unwrap_reference<T_arg2>::type, typename sigc::unwrap_reference<T_type2>::type> > sigc::group(const T_functor&, T_type1, T_type2) [with T_functor = int (*)(int, int); T_type1 = sigc::lambda<sigc::internal::lambda_select1>; T_type2 = int; typename sigc::unwrap_reference<T_type2>::type = int; typename sigc::unwrap_reference<T_arg2>::type = sigc::lambda<sigc::internal::lambda_select1>] (int (*<Tdd0e>) (int, int) & _A_func, struct lambda _A_1, int _A_2)
{
  struct T_lambda D.86469;
  typedef struct T_lambda T_lambda;

  sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, int>::lambda_group2 (&D.86469, _A_func, &_A_1, &_A_2);
  try
    {
      sigc::lambda<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, int> >::lambda (&<retval>, &D.86469);
      return <retval>;
    }
  finally
    {
      D.86469 = {CLOBBER};
    }
}


sigc::lambda_group2<T_functor, T_type1, T_type2>::lambda_group2(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_functor = int (*)(int, int); T_type1 = sigc::lambda<sigc::internal::lambda_select1>; T_type2 = int; typename sigc::type_trait<T_base>::take = int (* const&)(int, int); typename sigc::type_trait<T_derived>::take = const sigc::lambda<sigc::internal::lambda_select1>&; typename sigc::type_trait<T_arg3>::take = const int&] (struct lambda_group2 * const this, int (*<Tdd0e>) (int, int) & _A_func, const struct lambda & _A_1, const int & _A_2)
{
  struct value2_type * D.94562;
  struct functor_type * D.94563;

  sigc::lambda_base::lambda_base (this);
  D.94562 = &this->value2_;
  sigc::lambda<int>::lambda (D.94562, _A_2);
  D.94563 = &this->func_;
  sigc::adaptor_functor<sigc::pointer_functor2<int, int, int> >::adaptor_functor<int (*)(int, int)> (D.94563, _A_func);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, int>; typename sigc::type_trait<T_base>::take = const sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, int>&] (struct lambda * const this, const struct lambda_group2 & v)
{
  struct lambda_core * D.94564;

  D.94564 = &this->D.76327;
  sigc::internal::lambda_core<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, int>, true>::lambda_core (D.94564, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, int>] (struct lambda_core * const this, const struct lambda_group2 & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1) const [with T_arg1 = int; T_type = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, int>; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1>::type = int] (const struct lambda_core * const this, int _A_1)
{
  type D.94565;
  const struct lambda_group2 * D.94566;

  D.94566 = &this->value_;
  D.94565 = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, int>::operator()<int&> (D.94566, &_A_1);
  return D.94565;
}


typename sigc::lambda_group2<T_functor, T_type1, T_type2>::deduce_result_type<T_arg1>::type sigc::lambda_group2<T_functor, T_type1, T_type2>::operator()(T_arg1) const [with T_arg1 = int&; T_functor = int (*)(int, int); T_type1 = sigc::lambda<sigc::internal::lambda_select1>; T_type2 = int; typename sigc::lambda_group2<T_functor, T_type1, T_type2>::deduce_result_type<T_arg1>::type = int] (const struct lambda_group2 * const this, int & _A_1)
{
  type D.94569;
  const struct lambda_core * D.94570;
  int D.94571;
  const struct lambda_core * D.94572;
  int & D.94573;
  struct functor_type * D.94574;

  D.94570 = &this->value2_.D.41753;
  D.94571 = sigc::internal::lambda_core<int, false>::operator()<int&> (D.94570, _A_1);
  D.94572 = &this->value1_.D.40074;
  D.94573 = sigc::internal::lambda_core<sigc::internal::lambda_select1, true>::operator()<int&> (D.94572, _A_1);
  D.94574 = &this->func_;
  D.94569 = sigc::adaptor_functor<sigc::pointer_functor2<int, int, int> >::operator()<int&, int> (D.94574, D.94573, D.94571);
  return D.94569;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1) const [with T_arg1 = int&; T_type = sigc::internal::lambda_select1; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1>::type = int&] (const struct lambda_core * const this, int & _A_1)
{
  int & D.94577;
  const struct lambda_select1 * D.94578;

  D.94578 = &this->value_;
  D.94577 = sigc::internal::lambda_select1::operator()<int&> (D.94578, _A_1);
  return D.94577;
}


typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1, T_arg2>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1, T_arg2) const [with T_arg1 = int&; T_arg2 = int; T_functor = sigc::pointer_functor2<int, int, int>; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct adaptor_functor * const this, int & _A_arg1, int _A_arg2)
{
  type D.94580;
  struct pointer_functor2 * D.94581;

  D.94581 = &this->functor_;
  D.94580 = sigc::pointer_functor2<int, int, int>::operator() (D.94581, _A_arg1, &_A_arg2);
  return D.94580;
}


sigc::lambda<sigc::lambda_group2<T_functor, typename sigc::unwrap_reference<T_arg2>::type, typename sigc::unwrap_reference<T_type2>::type> > sigc::group(const T_functor&, T_type1, T_type2) [with T_functor = int (*)(int, int); T_type1 = int; T_type2 = int; typename sigc::unwrap_reference<T_type2>::type = int; typename sigc::unwrap_reference<T_arg2>::type = int] (int (*<Tdd0e>) (int, int) & _A_func, int _A_1, int _A_2)
{
  struct T_lambda D.86610;
  typedef struct T_lambda T_lambda;

  sigc::lambda_group2<int (*)(int, int), int, int>::lambda_group2 (&D.86610, _A_func, &_A_1, &_A_2);
  try
    {
      sigc::lambda<sigc::lambda_group2<int (*)(int, int), int, int> >::lambda (&<retval>, &D.86610);
      return <retval>;
    }
  finally
    {
      D.86610 = {CLOBBER};
    }
}


sigc::lambda_group2<T_functor, T_type1, T_type2>::lambda_group2(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_functor = int (*)(int, int); T_type1 = int; T_type2 = int; typename sigc::type_trait<T_base>::take = int (* const&)(int, int); typename sigc::type_trait<T_derived>::take = const int&; typename sigc::type_trait<T_arg3>::take = const int&] (struct lambda_group2 * const this, int (*<Tdd0e>) (int, int) & _A_func, const int & _A_1, const int & _A_2)
{
  struct value1_type * D.94588;
  struct value2_type * D.94589;
  struct functor_type * D.94590;

  sigc::lambda_base::lambda_base (this);
  D.94588 = &this->value1_;
  sigc::lambda<int>::lambda (D.94588, _A_1);
  D.94589 = &this->value2_;
  sigc::lambda<int>::lambda (D.94589, _A_2);
  D.94590 = &this->func_;
  sigc::adaptor_functor<sigc::pointer_functor2<int, int, int> >::adaptor_functor<int (*)(int, int)> (D.94590, _A_func);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_group2<int (*)(int, int), int, int>; typename sigc::type_trait<T_base>::take = const sigc::lambda_group2<int (*)(int, int), int, int>&] (struct lambda * const this, const struct lambda_group2 & v)
{
  struct lambda_core * D.94591;

  D.94591 = &this->D.77233;
  sigc::internal::lambda_core<sigc::lambda_group2<int (*)(int, int), int, int>, true>::lambda_core (D.94591, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_group2<int (*)(int, int), int, int>] (struct lambda_core * const this, const struct lambda_group2 & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


sigc::internal::lambda_core<T_type, true>::result_type sigc::internal::lambda_core<T_type, true>::operator()() const [with T_type = sigc::lambda_group2<int (*)(int, int), int, int>; sigc::internal::lambda_core<T_type, true>::result_type = int] (const struct lambda_core * const this)
{
  result_type D.94592;
  const struct lambda_group2 * D.94593;

  D.94593 = &this->value_;
  D.94592 = sigc::lambda_group2<int (*)(int, int), int, int>::operator() (D.94593);
  return D.94592;
}


sigc::lambda_group2<T_functor, T_type1, T_type2>::result_type sigc::lambda_group2<T_functor, T_type1, T_type2>::operator()() const [with T_functor = int (*)(int, int); T_type1 = int; T_type2 = int; sigc::lambda_group2<T_functor, T_type1, T_type2>::result_type = int] (const struct lambda_group2 * const this)
{
  result_type D.94596;
  const struct lambda_core * D.94597;
  int D.94598;
  const struct lambda_core * D.94599;
  int D.94600;
  struct functor_type * D.94601;

  D.94597 = &this->value2_.D.41753;
  D.94598 = sigc::internal::lambda_core<int, false>::operator() (D.94597);
  D.94599 = &this->value1_.D.41753;
  D.94600 = sigc::internal::lambda_core<int, false>::operator() (D.94599);
  D.94601 = &this->func_;
  D.94596 = sigc::adaptor_functor<sigc::pointer_functor2<int, int, int> >::operator()<int, int> (D.94601, D.94600, D.94598);
  return D.94596;
}


typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1, T_arg2>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1, T_arg2) const [with T_arg1 = int; T_arg2 = int; T_functor = sigc::pointer_functor2<int, int, int>; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct adaptor_functor * const this, int _A_arg1, int _A_arg2)
{
  type D.94604;
  struct pointer_functor2 * D.94605;

  D.94605 = &this->functor_;
  D.94604 = sigc::pointer_functor2<int, int, int>::operator() (D.94605, &_A_arg1, &_A_arg2);
  return D.94604;
}


sigc::lambda<sigc::lambda_group1<T_functor, typename sigc::unwrap_reference<T_arg2>::type> > sigc::group(const T_functor&, T_type1) [with T_functor = sigc::pointer_functor1<int, void>; T_type1 = int; typename sigc::unwrap_reference<T_arg2>::type = int] (const struct pointer_functor1 & _A_func, int _A_1)
{
  struct T_lambda D.86644;
  typedef struct T_lambda T_lambda;

  sigc::lambda_group1<sigc::pointer_functor1<int, void>, int>::lambda_group1 (&D.86644, _A_func, &_A_1);
  try
    {
      sigc::lambda<sigc::lambda_group1<sigc::pointer_functor1<int, void>, int> >::lambda (&<retval>, &D.86644);
      return <retval>;
    }
  finally
    {
      D.86644 = {CLOBBER};
    }
}


sigc::lambda_group1<T_functor, T_type1>::lambda_group1(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take) [with T_functor = sigc::pointer_functor1<int, void>; T_type1 = int; typename sigc::type_trait<T_base>::take = const sigc::pointer_functor1<int, void>&; typename sigc::type_trait<T_derived>::take = const int&] (struct lambda_group1 * const this, const struct pointer_functor1 & _A_func, const int & _A_1)
{
  struct value1_type * D.94612;
  struct functor_type * D.94613;

  sigc::lambda_base::lambda_base (this);
  D.94612 = &this->value1_;
  sigc::lambda<int>::lambda (D.94612, _A_1);
  D.94613 = &this->func_;
  sigc::adaptor_functor<sigc::pointer_functor1<int, void> >::adaptor_functor (D.94613, _A_func);
}


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


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_group1<sigc::pointer_functor1<int, void>, int>; typename sigc::type_trait<T_base>::take = const sigc::lambda_group1<sigc::pointer_functor1<int, void>, int>&] (struct lambda * const this, const struct lambda_group1 & v)
{
  struct lambda_core * D.94614;

  D.94614 = &this->D.78516;
  sigc::internal::lambda_core<sigc::lambda_group1<sigc::pointer_functor1<int, void>, int>, true>::lambda_core (D.94614, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_group1<sigc::pointer_functor1<int, void>, int>] (struct lambda_core * const this, const struct lambda_group1 & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


sigc::internal::lambda_core<T_type, true>::result_type sigc::internal::lambda_core<T_type, true>::operator()() const [with T_type = sigc::lambda_group1<sigc::pointer_functor1<int, void>, int>; sigc::internal::lambda_core<T_type, true>::result_type = void] (const struct lambda_core * const this)
{
  const struct lambda_group1 * D.94615;

  D.94615 = &this->value_;
  sigc::lambda_group1<sigc::pointer_functor1<int, void>, int>::operator() (D.94615);
  return;
}


sigc::lambda_group1<T_functor, T_type1>::result_type sigc::lambda_group1<T_functor, T_type1>::operator()() const [with T_functor = sigc::pointer_functor1<int, void>; T_type1 = int; sigc::lambda_group1<T_functor, T_type1>::result_type = void] (const struct lambda_group1 * const this)
{
  const struct lambda_core * D.94617;
  int D.94618;
  struct functor_type * D.94619;

  D.94617 = &this->value1_.D.41753;
  D.94618 = sigc::internal::lambda_core<int, false>::operator() (D.94617);
  D.94619 = &this->func_;
  sigc::adaptor_functor<sigc::pointer_functor1<int, void> >::operator()<int> (D.94619, D.94618);
  return;
}


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

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


T_return sigc::pointer_functor1<T_arg1, T_return>::operator()(typename sigc::type_trait<T_base>::take) const [with T_arg1 = int; T_return = void; typename sigc::type_trait<T_base>::take = const int&] (const struct pointer_functor1 * const this, const int & _A_a1)
{
  void (*<Tf35b>) (int) D.94623;
  int D.94624;

  D.94623 = this->func_ptr_;
  D.94624 = *_A_a1;
  D.94623 (D.94624);
  return;
}


sigc::slot<T_return, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot() [with T_return = void] (struct slot * const this)
{
  struct slot0 * D.94626;

  D.94626 = &this->D.68395;
  sigc::slot0<void>::slot0 (D.94626);
  try
    {

    }
  catch
    {
      D.94626 = &this->D.68395;
      sigc::slot0<void>::~slot0 (D.94626);
    }
}


sigc::slot0<T_return>::slot0() [with T_return = void] (struct slot0 * const this)
{
  struct slot_base * D.94627;

  D.94627 = &this->D.68353;
  sigc::slot_base::slot_base (D.94627);
  try
    {

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


{anonymous}::book::book(const string&) (struct book * const this, const struct string & name)
{
  struct trackable * D.94628;
  struct string * D.94629;

  D.94628 = &this->D.39605;
  sigc::trackable::trackable (D.94628);
  try
    {
      D.94629 = &this->name_;
      std::basic_string<char>::basic_string (D.94629, name);
      try
        {

        }
      catch
        {
          D.94629 = &this->name_;
          std::basic_string<char>::~basic_string (D.94629);
        }
    }
  catch
    {
      D.94628 = &this->D.39605;
      sigc::trackable::~trackable (D.94628);
    }
}


sigc::reference_wrapper<T_type> sigc::ref(T_type&) [with T_type = {anonymous}::book] (struct book & v)
{
  struct reference_wrapper D.94631;
  struct reference_wrapper D.86043;

  sigc::reference_wrapper<{anonymous}::book>::reference_wrapper (&D.86043, v);
  try
    {
      D.94631 = D.86043;
      return D.94631;
    }
  finally
    {
      D.86043 = {CLOBBER};
    }
}


sigc::reference_wrapper<T_type>::reference_wrapper(T_type&) [with T_type = {anonymous}::book] (struct reference_wrapper * const this, struct book & v)
{
  this->value_ = v;
}


sigc::lambda<sigc::lambda_group1<T_functor, typename sigc::unwrap_reference<T_arg2>::type> > sigc::group(const T_functor&, T_type1) [with T_functor = void (*)(std::basic_string<char>&); T_type1 = sigc::reference_wrapper<{anonymous}::book>; typename sigc::unwrap_reference<T_arg2>::type = {anonymous}::book&] (void (*<Tf7e8>) (struct basic_string &) & _A_func, struct reference_wrapper _A_1)
{
  struct T_lambda D.86667;
  struct book & D.94635;
  typedef struct T_lambda T_lambda;

  D.94635 = sigc::reference_wrapper<{anonymous}::book>::operator {anonymous}::book& (&_A_1);
  sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&>::lambda_group1 (&D.86667, _A_func, D.94635);
  try
    {
      sigc::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> >::lambda (&<retval>, &D.86667);
      return <retval>;
    }
  finally
    {
      D.86667 = {CLOBBER};
    }
}


sigc::lambda_group1<T_functor, T_type1>::lambda_group1(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take) [with T_functor = void (*)(std::basic_string<char>&); T_type1 = {anonymous}::book&; typename sigc::type_trait<T_base>::take = void (* const&)(std::basic_string<char>&); typename sigc::type_trait<T_derived>::take = {anonymous}::book&] (struct lambda_group1 * const this, void (*<Tf7e8>) (struct basic_string &) & _A_func, struct book & _A_1)
{
  struct value1_type * D.94639;
  struct functor_type * D.94640;

  sigc::lambda_base::lambda_base (this);
  D.94639 = &this->value1_;
  sigc::lambda<{anonymous}::book&>::lambda (D.94639, _A_1);
  D.94640 = &this->func_;
  sigc::adaptor_functor<sigc::pointer_functor1<std::basic_string<char>&, void> >::adaptor_functor<void (*)(std::basic_string<char>&)> (D.94640, _A_func);
}


sigc::adaptor_functor<T_functor>::adaptor_functor(const T_type&) [with T_type = void (*)(std::basic_string<char>&); T_functor = sigc::pointer_functor1<std::basic_string<char>&, void>] (struct adaptor_functor * const this, void (*<Tf7e8>) (struct basic_string &) & _A_type)
{
  void (*<Tf7e2>) (struct basic_string &) D.94641;
  struct pointer_functor1 * D.94642;

  sigc::adaptor_base::adaptor_base (this);
  D.94641 = *_A_type;
  D.94642 = &this->functor_;
  sigc::pointer_functor1<std::basic_string<char>&, void>::pointer_functor1 (D.94642, D.94641);
}


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


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&>; typename sigc::type_trait<T_base>::take = const sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&>&] (struct lambda * const this, const struct lambda_group1 & v)
{
  struct lambda_core * D.94643;

  D.94643 = &this->D.79850;
  sigc::internal::lambda_core<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&>, true>::lambda_core (D.94643, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&>] (struct lambda_core * const this, const struct lambda_group1 & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


sigc::slot<T_return, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::slot(const T_functor&) [with T_functor = sigc::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> >; T_return = void] (struct slot * const this, const struct lambda & _A_func)
{
  struct slot0 * D.94644;

  D.94644 = &this->D.68395;
  sigc::slot0<void>::slot0<sigc::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> > > (D.94644, _A_func);
  try
    {

    }
  catch
    {
      D.94644 = &this->D.68395;
      sigc::slot0<void>::~slot0 (D.94644);
    }
}


sigc::slot0<T_return>::slot0(const T_functor&) [with T_functor = sigc::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> >; T_return = void] (struct slot0 * const this, const struct lambda & _A_func)
{
  void * D.90086;
  struct slot_base * D.94645;
  struct rep_type * D.94646;
  void * (*<T1711>) (void *) D.94647;

  D.90086 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> > >::typed_slot_rep (D.90086, _A_func);
    }
  catch
    {
      operator delete (D.90086);
    }
  D.94645 = &this->D.68353;
  sigc::slot_base::slot_base (D.94645, D.90086);
  try
    {
      D.94646 = this->D.68353.rep_;
      D.94647 = sigc::internal::slot_call0<sigc::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> >, void>::address ();
      D.94646->call_ = D.94647;
    }
  catch
    {
      D.94645 = &this->D.68353;
      sigc::slot_base::~slot_base (D.94645);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> >] (struct typed_slot_rep * const this, const struct lambda & functor)
{
  struct slot_rep * D.94650;
  struct adaptor_type * D.94651;
  struct slot_do_bind D.91996;

  D.94650 = &this->D.90075;
  sigc::internal::slot_rep::slot_rep (D.94650, 0B, destroy, dup);
  try
    {
      this->functor_ = *functor;
      D.94651 = &this->functor_;
      D.94650 = &this->D.90075;
      sigc::internal::slot_do_bind::slot_do_bind (&D.91996, D.94650);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> > > (&D.91996, D.94651);
        }
      finally
        {
          D.91996 = {CLOBBER};
        }
    }
  catch
    {
      D.94650 = &this->D.90075;
      sigc::internal::slot_rep::~slot_rep (D.94650);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> >] (void * data)
{
  void * D.94654;
  void * D.92431;
  struct slot_rep * a_rep;

  a_rep = data;
  D.92431 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> > >::typed_slot_rep (D.92431, a_rep);
    }
  catch
    {
      operator delete (D.92431);
    }
  D.94654 = D.92431;
  return D.94654;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> >] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.94658;
  struct slot_rep * D.94659;
  struct adaptor_type * D.94660;
  struct slot_do_bind D.92531;

  D.94658 = cl->D.90075.call_;
  D.94659 = &this->D.90075;
  sigc::internal::slot_rep::slot_rep (D.94659, D.94658, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.94660 = &this->functor_;
      D.94659 = &this->D.90075;
      sigc::internal::slot_do_bind::slot_do_bind (&D.92531, D.94659);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> > > (&D.92531, D.94660);
        }
      finally
        {
          D.92531 = {CLOBBER};
        }
    }
  catch
    {
      D.94659 = &this->D.90075;
      sigc::internal::slot_rep::~slot_rep (D.94659);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> >] (void * data)
{
  struct adaptor_type * D.94663;
  struct slot_do_unbind D.92416;
  void * D.94664;
  struct self * self_;

  self_ = data;
  self_->D.90075.call_ = 0B;
  self_->D.90075.destroy_ = 0B;
  D.94663 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.92416, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> > > (&D.92416, D.94663);
    }
  finally
    {
      D.92416 = {CLOBBER};
    }
  D.94664 = 0B;
  return D.94664;
}


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::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> >] (const struct slot_do_unbind & _A_action, const struct lambda & _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::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> > > (&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::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> >] (const struct limit_derived_target & _A_action, const struct lambda & _A_functor)
{
  sigc::visitor<sigc::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::lambda<T_type> >::do_visit_each(const T_action&, const sigc::lambda<T_type>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_type = sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&>] (const struct limit_derived_target & _A_action, const struct lambda & _A_target)
{
  const struct lambda_group1 * D.94668;

  D.94668 = &_A_target->D.79850.value_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> > (_A_action, D.94668);
}


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::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&>] (const struct limit_derived_target & _A_action, const struct lambda_group1 & _A_functor)
{
  sigc::visitor<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::lambda_group1<T_functor, T_type1> >::do_visit_each(const T_action&, const sigc::lambda_group1<T_functor, T_type1>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = void (*)(std::basic_string<char>&); T_type1 = {anonymous}::book&] (const struct limit_derived_target & _A_action, const struct lambda_group1 & _A_target)
{
  const struct value1_type * D.94669;
  struct functor_type * D.94670;

  D.94669 = &_A_target->value1_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::lambda<{anonymous}::book&> > (_A_action, D.94669);
  D.94670 = &_A_target->func_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::adaptor_functor<sigc::pointer_functor1<std::basic_string<char>&, void> > > (_A_action, D.94670);
}


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


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

  D.94671 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::pointer_functor1<std::basic_string<char>&, void> > (_A_action, D.94671);
}


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


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


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


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


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = sigc::trackable*; T_action = sigc::internal::slot_do_bind; T_functor = sigc::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> >] (const struct slot_do_bind & _A_action, const struct lambda & _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::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> > > (&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::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> >] (const struct limit_derived_target & _A_action, const struct lambda & _A_functor)
{
  sigc::visitor<sigc::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> > >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::lambda<T_type> >::do_visit_each(const T_action&, const sigc::lambda<T_type>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_type = sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&>] (const struct limit_derived_target & _A_action, const struct lambda & _A_target)
{
  const struct lambda_group1 * D.94673;

  D.94673 = &_A_target->D.79850.value_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> > (_A_action, D.94673);
}


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::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&>] (const struct limit_derived_target & _A_action, const struct lambda_group1 & _A_functor)
{
  sigc::visitor<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> >::do_visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::lambda_group1<T_functor, T_type1> >::do_visit_each(const T_action&, const sigc::lambda_group1<T_functor, T_type1>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = void (*)(std::basic_string<char>&); T_type1 = {anonymous}::book&] (const struct limit_derived_target & _A_action, const struct lambda_group1 & _A_target)
{
  const struct value1_type * D.94674;
  struct functor_type * D.94675;

  D.94674 = &_A_target->value1_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::lambda<{anonymous}::book&> > (_A_action, D.94674);
  D.94675 = &_A_target->func_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::adaptor_functor<sigc::pointer_functor1<std::basic_string<char>&, void> > > (_A_action, D.94675);
}


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


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

  D.94676 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::pointer_functor1<std::basic_string<char>&, void> > (_A_action, D.94676);
}


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


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


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


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


static void* (* sigc::internal::slot_call0<T_functor, T_return>::address())(void*) [with T_functor = sigc::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> >; T_return = void; sigc::internal::hook = void* (*)(void*)] ()
{
  void * (*hook) (void *) D.94677;

  D.94677 = call_it;
  return D.94677;
}


static T_return sigc::internal::slot_call0<T_functor, T_return>::call_it(sigc::internal::slot_rep*) [with T_functor = sigc::lambda<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&> >; T_return = void] (struct slot_rep * rep)
{
  struct lambda_core * D.94679;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.94679 = &typed_rep->functor_.D.79850;
  sigc::internal::lambda_core<sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&>, true>::operator() (D.94679);
  return;
}


sigc::internal::lambda_core<T_type, true>::result_type sigc::internal::lambda_core<T_type, true>::operator()() const [with T_type = sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&>; sigc::internal::lambda_core<T_type, true>::result_type = void] (const struct lambda_core * const this)
{
  const struct lambda_group1 * D.94681;

  D.94681 = &this->value_;
  sigc::lambda_group1<void (*)(std::basic_string<char>&), {anonymous}::book&>::operator() (D.94681);
  return;
}


sigc::lambda_group1<T_functor, T_type1>::result_type sigc::lambda_group1<T_functor, T_type1>::operator()() const [with T_functor = void (*)(std::basic_string<char>&); T_type1 = {anonymous}::book&; sigc::lambda_group1<T_functor, T_type1>::result_type = void] (const struct lambda_group1 * const this)
{
  struct book D.92612;
  const struct lambda_core * D.94683;
  struct book & D.94684;
  struct functor_type * D.94685;

  D.94683 = &this->value1_.D.68808;
  D.94684 = sigc::internal::lambda_core<{anonymous}::book&, false>::operator() (D.94683);
  {anonymous}::book::book (&D.92612, D.94684);
  try
    {
      D.94685 = &this->func_;
      sigc::adaptor_functor<sigc::pointer_functor1<std::basic_string<char>&, void> >::operator()<{anonymous}::book> (D.94685, &D.92612);
    }
  finally
    {
      {anonymous}::book::~book (&D.92612);
      D.92612 = {CLOBBER};
    }
  return;
}


{anonymous}::book::book(const {anonymous}::book&) (struct book * const this, const struct book & D.39624)
{
  const struct trackable * D.94688;
  struct trackable * D.94689;
  const struct string * D.94690;
  struct string * D.94691;

  D.94688 = &D.39624->D.39605;
  D.94689 = &this->D.39605;
  sigc::trackable::trackable (D.94689, D.94688);
  try
    {
      D.94690 = &D.39624->name_;
      D.94691 = &this->name_;
      std::basic_string<char>::basic_string (D.94691, D.94690);
      try
        {

        }
      catch
        {
          D.94691 = &this->name_;
          std::basic_string<char>::~basic_string (D.94691);
        }
    }
  catch
    {
      D.94689 = &this->D.39605;
      sigc::trackable::~trackable (D.94689);
    }
}


typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1) const [with T_arg1 = {anonymous}::book; T_functor = sigc::pointer_functor1<std::basic_string<char>&, void>; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type = void] (const struct adaptor_functor * const this, struct book & restrict _A_arg1)
{
  struct string & D.94693;
  struct pointer_functor1 * D.94694;

  D.94693 = {anonymous}::book::operator std::string& (_A_arg1);
  D.94694 = &this->functor_;
  sigc::pointer_functor1<std::basic_string<char>&, void>::operator() (D.94694, D.94693);
  return;
}


T_return sigc::pointer_functor1<T_arg1, T_return>::operator()(typename sigc::type_trait<T_base>::take) const [with T_arg1 = std::basic_string<char>&; T_return = void; typename sigc::type_trait<T_base>::take = std::basic_string<char>&] (const struct pointer_functor1 * const this, struct basic_string & _A_a1)
{
  void (*<Tf7e2>) (struct basic_string &) D.94696;

  D.94696 = this->func_ptr_;
  D.94696 (_A_a1);
  return;
}


sigc::slot<void>& sigc::slot<void>::operator=(const sigc::slot<void>&) (struct slot * const this, const struct slot & D.70751)
{
  const struct slot0 * D.94698;
  struct slot0 * D.94699;
  struct slot & D.94700;

  D.94698 = &D.70751->D.68395;
  D.94699 = &this->D.68395;
  sigc::slot0<void>::operator= (D.94699, D.94698);
  D.94700 = this;
  return D.94700;
}


sigc::slot0<T_return>& sigc::slot0<T_return>::operator=(const sigc::slot0<T_return>&) [with T_return = void] (struct slot0 * const this, const struct slot0 & src)
{
  const struct slot_base * D.94702;
  struct slot_base * D.94703;
  struct slot0 & D.94704;

  D.94702 = &src->D.68353;
  D.94703 = &this->D.68353;
  sigc::slot_base::operator= (D.94703, D.94702);
  D.94704 = this;
  return D.94704;
}


{anonymous}::book::operator std::string&() (struct book * const this)
{
  struct string & D.94706;

  D.94706 = &this->name_;
  return D.94706;
}


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

  D.94709 = std::basic_string<char>::size (__str);
  D.94710 = (long int) D.94709;
  D.94711 = std::basic_string<char>::data (__str);
  D.94708 = std::__ostream_insert<char, std::char_traits<char> > (__os, D.94711, D.94710);
  return D.94708;
}


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

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


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.94720;
  char * D.94721;

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


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

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


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

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


T_return sigc::slot0<T_return>::operator()() const [with T_return = void] (const struct slot0 * const this)
{
  bool retval.9;
  bool iftmp.10;
  const struct slot_base * D.94733;
  bool D.94734;
  bool D.94735;
  bool D.94737;
  bool D.94738;
  struct rep_type * D.94742;
  void * (*<T1711>) (void *) D.94743;

  D.94733 = &this->D.68353;
  D.94734 = sigc::slot_base::empty (D.94733);
  D.94735 = ~D.94734;
  if (D.94735 != 0) goto <D.94736>; else goto <D.94731>;
  <D.94736>:
  D.94733 = &this->D.68353;
  D.94737 = sigc::slot_base::blocked (D.94733);
  D.94738 = ~D.94737;
  if (D.94738 != 0) goto <D.94739>; else goto <D.94731>;
  <D.94739>:
  iftmp.10 = 1;
  goto <D.94732>;
  <D.94731>:
  iftmp.10 = 0;
  <D.94732>:
  retval.9 = iftmp.10;
  if (retval.9 != 0) goto <D.94740>; else goto <D.94741>;
  <D.94740>:
  D.94742 = this->D.68353.rep_;
  D.94743 = D.94742->call_;
  D.94742 = this->D.68353.rep_;
  D.94743 (D.94742);
  return;
  <D.94741>:
  return;
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.94745;
  bool iftmp.11;
  struct rep_type * D.94750;
  void * (*<T1711>) (void *) D.94752;

  D.94750 = this->rep_;
  if (D.94750 == 0B) goto <D.94747>; else goto <D.94751>;
  <D.94751>:
  D.94750 = this->rep_;
  D.94752 = D.94750->call_;
  if (D.94752 == 0B) goto <D.94747>; else goto <D.94748>;
  <D.94747>:
  iftmp.11 = 1;
  goto <D.94749>;
  <D.94748>:
  iftmp.11 = 0;
  <D.94749>:
  D.94745 = iftmp.11;
  return D.94745;
}


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

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


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2, T_arg3) const [with T_arg1 = int; T_arg2 = int; T_arg3 = int; T_type = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> >; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type = int] (const struct lambda_core * const this, int _A_1, int _A_2, int _A_3)
{
  type D.94756;
  const struct lambda_group2 * D.94757;

  D.94757 = &this->value_;
  D.94756 = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> >::operator()<int&, int&, int&> (D.94757, &_A_1, &_A_2, &_A_3);
  return D.94756;
}


typename sigc::lambda_group2<T_functor, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type sigc::lambda_group2<T_functor, T_type1, T_type2>::operator()(T_arg1, T_arg2, T_arg3) const [with T_arg1 = int&; T_arg2 = int&; T_arg3 = int&; T_functor = int (*)(int, int); T_type1 = sigc::lambda<sigc::internal::lambda_select1>; T_type2 = sigc::lambda<sigc::internal::lambda_select2>; typename sigc::lambda_group2<T_functor, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type = int] (const struct lambda_group2 * const this, int & _A_1, int & _A_2, int & _A_3)
{
  type D.94760;
  const struct lambda_core * D.94761;
  int & D.94762;
  const struct lambda_core * D.94763;
  int & D.94764;
  struct functor_type * D.94765;

  D.94761 = &this->value2_.D.40511;
  D.94762 = sigc::internal::lambda_core<sigc::internal::lambda_select2, true>::operator()<int&, int&, int&> (D.94761, _A_1, _A_2, _A_3);
  D.94763 = &this->value1_.D.40074;
  D.94764 = sigc::internal::lambda_core<sigc::internal::lambda_select1, true>::operator()<int&, int&, int&> (D.94763, _A_1, _A_2, _A_3);
  D.94765 = &this->func_;
  D.94760 = sigc::adaptor_functor<sigc::pointer_functor2<int, int, int> >::operator()<int&, int&> (D.94765, D.94764, D.94762);
  return D.94760;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2, T_arg3) const [with T_arg1 = int&; T_arg2 = int&; T_arg3 = int&; T_type = sigc::internal::lambda_select2; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type = int&] (const struct lambda_core * const this, int & _A_1, int & _A_2, int & _A_3)
{
  int & D.94769;
  const struct lambda_select2 * D.94770;

  D.94770 = &this->value_;
  D.94769 = sigc::internal::lambda_select2::operator()<int&, int&, int&> (D.94770, _A_1, _A_2, _A_3);
  return D.94769;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2, T_arg3) const [with T_arg1 = int&; T_arg2 = int&; T_arg3 = int&; T_type = sigc::internal::lambda_select1; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type = int&] (const struct lambda_core * const this, int & _A_1, int & _A_2, int & _A_3)
{
  int & D.94772;
  const struct lambda_select1 * D.94773;

  D.94773 = &this->value_;
  D.94772 = sigc::internal::lambda_select1::operator()<int&, int&, int&> (D.94773, _A_1, _A_2, _A_3);
  return D.94772;
}


sigc::pointer_functor1<T_arg1, T_return> sigc::ptr_fun(T_return (*)(T_arg1)) [with T_arg1 = int; T_return = void] (void (*<Tf35b>) (int) _A_func)
{
  struct pointer_functor1 D.94775;
  struct pointer_functor1 D.86632;

  sigc::pointer_functor1<int, void>::pointer_functor1 (&D.86632, _A_func);
  try
    {
      D.94775 = D.86632;
      return D.94775;
    }
  finally
    {
      D.86632 = {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 = void; sigc::pointer_functor1<T_arg1, T_return>::function_type = void (*)(int)] (struct pointer_functor1 * const this, void (*function_type) (int) _A_func)
{
  sigc::functor_base::functor_base (this);
  this->func_ptr_ = _A_func;
}


sigc::lambda<sigc::lambda_group1<T_functor, typename sigc::unwrap_reference<T_arg2>::type> > sigc::group(const T_functor&, T_type1) [with T_functor = sigc::pointer_functor1<int, void>; T_type1 = sigc::lambda<sigc::internal::lambda_select2>; typename sigc::unwrap_reference<T_arg2>::type = sigc::lambda<sigc::internal::lambda_select2>] (const struct pointer_functor1 & _A_func, struct lambda _A_1)
{
  struct T_lambda D.86796;
  typedef struct T_lambda T_lambda;

  sigc::lambda_group1<sigc::pointer_functor1<int, void>, sigc::lambda<sigc::internal::lambda_select2> >::lambda_group1 (&D.86796, _A_func, &_A_1);
  try
    {
      sigc::lambda<sigc::lambda_group1<sigc::pointer_functor1<int, void>, sigc::lambda<sigc::internal::lambda_select2> > >::lambda (&<retval>, &D.86796);
      return <retval>;
    }
  finally
    {
      D.86796 = {CLOBBER};
    }
}


sigc::lambda_group1<T_functor, T_type1>::lambda_group1(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take) [with T_functor = sigc::pointer_functor1<int, void>; T_type1 = sigc::lambda<sigc::internal::lambda_select2>; typename sigc::type_trait<T_base>::take = const sigc::pointer_functor1<int, void>&; typename sigc::type_trait<T_derived>::take = const sigc::lambda<sigc::internal::lambda_select2>&] (struct lambda_group1 * const this, const struct pointer_functor1 & _A_func, const struct lambda & _A_1)
{
  struct functor_type * D.94782;

  sigc::lambda_base::lambda_base (this);
  D.94782 = &this->func_;
  sigc::adaptor_functor<sigc::pointer_functor1<int, void> >::adaptor_functor (D.94782, _A_func);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_group1<sigc::pointer_functor1<int, void>, sigc::lambda<sigc::internal::lambda_select2> >; typename sigc::type_trait<T_base>::take = const sigc::lambda_group1<sigc::pointer_functor1<int, void>, sigc::lambda<sigc::internal::lambda_select2> >&] (struct lambda * const this, const struct lambda_group1 & v)
{
  struct lambda_core * D.94783;

  D.94783 = &this->D.80771;
  sigc::internal::lambda_core<sigc::lambda_group1<sigc::pointer_functor1<int, void>, sigc::lambda<sigc::internal::lambda_select2> >, true>::lambda_core (D.94783, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_group1<sigc::pointer_functor1<int, void>, sigc::lambda<sigc::internal::lambda_select2> >] (struct lambda_core * const this, const struct lambda_group1 & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2) const [with T_arg1 = int; T_arg2 = int; T_type = sigc::lambda_group1<sigc::pointer_functor1<int, void>, sigc::lambda<sigc::internal::lambda_select2> >; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2>::type = void] (const struct lambda_core * const this, int _A_1, int _A_2)
{
  const struct lambda_group1 * D.94784;

  D.94784 = &this->value_;
  sigc::lambda_group1<sigc::pointer_functor1<int, void>, sigc::lambda<sigc::internal::lambda_select2> >::operator()<int&, int&> (D.94784, &_A_1, &_A_2);
  return;
}


typename sigc::lambda_group1<T_functor, T_type1>::deduce_result_type<T_arg1, T_arg2>::type sigc::lambda_group1<T_functor, T_type1>::operator()(T_arg1, T_arg2) const [with T_arg1 = int&; T_arg2 = int&; T_functor = sigc::pointer_functor1<int, void>; T_type1 = sigc::lambda<sigc::internal::lambda_select2>; typename sigc::lambda_group1<T_functor, T_type1>::deduce_result_type<T_arg1, T_arg2>::type = void] (const struct lambda_group1 * const this, int & _A_1, int & _A_2)
{
  const struct lambda_core * D.94786;
  int & D.94787;
  struct functor_type * D.94788;

  D.94786 = &this->value1_.D.40511;
  D.94787 = sigc::internal::lambda_core<sigc::internal::lambda_select2, true>::operator()<int&, int&> (D.94786, _A_1, _A_2);
  D.94788 = &this->func_;
  sigc::adaptor_functor<sigc::pointer_functor1<int, void> >::operator()<int&> (D.94788, D.94787);
  return;
}


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

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


sigc::lambda<sigc::lambda_group2<T_functor, typename sigc::unwrap_reference<T_arg2>::type, typename sigc::unwrap_reference<T_type2>::type> > sigc::group(const T_functor&, T_type1, T_type2) [with T_functor = int (*)(int, int); T_type1 = sigc::lambda<sigc::internal::lambda_select1>; T_type2 = sigc::lambda<sigc::internal::lambda_select2>; typename sigc::unwrap_reference<T_type2>::type = sigc::lambda<sigc::internal::lambda_select2>; typename sigc::unwrap_reference<T_arg2>::type = sigc::lambda<sigc::internal::lambda_select1>] (int (*<Tdd0e>) (int, int) & _A_func, struct lambda _A_1, struct lambda _A_2)
{
  struct T_lambda D.86115;
  typedef struct T_lambda T_lambda;

  sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> >::lambda_group2 (&D.86115, _A_func, &_A_1, &_A_2);
  try
    {
      sigc::lambda<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> > >::lambda (&<retval>, &D.86115);
      return <retval>;
    }
  finally
    {
      D.86115 = {CLOBBER};
    }
}


sigc::lambda_group2<T_functor, T_type1, T_type2>::lambda_group2(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_functor = int (*)(int, int); T_type1 = sigc::lambda<sigc::internal::lambda_select1>; T_type2 = sigc::lambda<sigc::internal::lambda_select2>; typename sigc::type_trait<T_base>::take = int (* const&)(int, int); typename sigc::type_trait<T_derived>::take = const sigc::lambda<sigc::internal::lambda_select1>&; typename sigc::type_trait<T_arg3>::take = const sigc::lambda<sigc::internal::lambda_select2>&] (struct lambda_group2 * const this, int (*<Tdd0e>) (int, int) & _A_func, const struct lambda & _A_1, const struct lambda & _A_2)
{
  struct functor_type * D.94796;

  sigc::lambda_base::lambda_base (this);
  D.94796 = &this->func_;
  sigc::adaptor_functor<sigc::pointer_functor2<int, int, int> >::adaptor_functor<int (*)(int, int)> (D.94796, _A_func);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> >; typename sigc::type_trait<T_base>::take = const sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> >&] (struct lambda * const this, const struct lambda_group2 & v)
{
  struct lambda_core * D.94797;

  D.94797 = &this->D.72574;
  sigc::internal::lambda_core<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> >, true>::lambda_core (D.94797, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> >] (struct lambda_core * const this, const struct lambda_group2 & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


sigc::lambda<sigc::lambda_group2<T_functor, typename sigc::unwrap_reference<T_arg2>::type, typename sigc::unwrap_reference<T_type2>::type> > sigc::group(const T_functor&, T_type1, T_type2) [with T_functor = int (*)(int, int); T_type1 = sigc::lambda<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> > >; T_type2 = sigc::lambda<sigc::internal::lambda_select3>; typename sigc::unwrap_reference<T_type2>::type = sigc::lambda<sigc::internal::lambda_select3>; typename sigc::unwrap_reference<T_arg2>::type = sigc::lambda<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> > >] (int (*<Tdd0e>) (int, int) & _A_func, struct lambda _A_1, struct lambda _A_2)
{
  struct T_lambda D.86925;
  typedef struct T_lambda T_lambda;

  sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> > >, sigc::lambda<sigc::internal::lambda_select3> >::lambda_group2 (&D.86925, _A_func, &_A_1, &_A_2);
  try
    {
      sigc::lambda<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> > >, sigc::lambda<sigc::internal::lambda_select3> > >::lambda (&<retval>, &D.86925);
      return <retval>;
    }
  finally
    {
      D.86925 = {CLOBBER};
    }
}


sigc::lambda_group2<T_functor, T_type1, T_type2>::lambda_group2(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_functor = int (*)(int, int); T_type1 = sigc::lambda<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> > >; T_type2 = sigc::lambda<sigc::internal::lambda_select3>; typename sigc::type_trait<T_base>::take = int (* const&)(int, int); typename sigc::type_trait<T_derived>::take = const sigc::lambda<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> > >&; typename sigc::type_trait<T_arg3>::take = const sigc::lambda<sigc::internal::lambda_select3>&] (struct lambda_group2 * const this, int (*<Tdd0e>) (int, int) & _A_func, const struct lambda & _A_1, const struct lambda & _A_2)
{
  struct functor_type * D.94802;

  sigc::lambda_base::lambda_base (this);
  this->value1_ = *_A_1;
  D.94802 = &this->func_;
  sigc::adaptor_functor<sigc::pointer_functor2<int, int, int> >::adaptor_functor<int (*)(int, int)> (D.94802, _A_func);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> > >, sigc::lambda<sigc::internal::lambda_select3> >; typename sigc::type_trait<T_base>::take = const sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> > >, sigc::lambda<sigc::internal::lambda_select3> >&] (struct lambda * const this, const struct lambda_group2 & v)
{
  struct lambda_core * D.94803;

  D.94803 = &this->D.82125;
  sigc::internal::lambda_core<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> > >, sigc::lambda<sigc::internal::lambda_select3> >, true>::lambda_core (D.94803, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> > >, sigc::lambda<sigc::internal::lambda_select3> >] (struct lambda_core * const this, const struct lambda_group2 & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2, T_arg3) const [with T_arg1 = int; T_arg2 = int; T_arg3 = int; T_type = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> > >, sigc::lambda<sigc::internal::lambda_select3> >; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type = int] (const struct lambda_core * const this, int _A_1, int _A_2, int _A_3)
{
  type D.94804;
  const struct lambda_group2 * D.94805;

  D.94805 = &this->value_;
  D.94804 = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> > >, sigc::lambda<sigc::internal::lambda_select3> >::operator()<int&, int&, int&> (D.94805, &_A_1, &_A_2, &_A_3);
  return D.94804;
}


typename sigc::lambda_group2<T_functor, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type sigc::lambda_group2<T_functor, T_type1, T_type2>::operator()(T_arg1, T_arg2, T_arg3) const [with T_arg1 = int&; T_arg2 = int&; T_arg3 = int&; T_functor = int (*)(int, int); T_type1 = sigc::lambda<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> > >; T_type2 = sigc::lambda<sigc::internal::lambda_select3>; typename sigc::lambda_group2<T_functor, T_type1, T_type2>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type = int] (const struct lambda_group2 * const this, int & _A_1, int & _A_2, int & _A_3)
{
  type D.94808;
  const struct lambda_core * D.94809;
  int & D.94810;
  const struct lambda_core * D.94811;
  int D.94812;
  struct functor_type * D.94813;

  D.94809 = &this->value2_.D.45646;
  D.94810 = sigc::internal::lambda_core<sigc::internal::lambda_select3, true>::operator()<int&, int&, int&> (D.94809, _A_1, _A_2, _A_3);
  D.94811 = &this->value1_.D.72574;
  D.94812 = sigc::internal::lambda_core<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> >, true>::operator()<int&, int&, int&> (D.94811, _A_1, _A_2, _A_3);
  D.94813 = &this->func_;
  D.94808 = sigc::adaptor_functor<sigc::pointer_functor2<int, int, int> >::operator()<int, int&> (D.94813, D.94812, D.94810);
  return D.94808;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2, T_arg3) const [with T_arg1 = int&; T_arg2 = int&; T_arg3 = int&; T_type = sigc::internal::lambda_select3; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type = int&] (const struct lambda_core * const this, int & _A_1, int & _A_2, int & _A_3)
{
  int & D.94818;
  const struct lambda_select3 * D.94819;

  D.94819 = &this->value_;
  D.94818 = sigc::internal::lambda_select3::operator()<int&, int&, int&> (D.94819, _A_1, _A_2, _A_3);
  return D.94818;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1, T_arg2, T_arg3) const [with T_arg1 = int&; T_arg2 = int&; T_arg3 = int&; T_type = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> >; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type = int] (const struct lambda_core * const this, int & _A_1, int & _A_2, int & _A_3)
{
  type D.94821;
  const struct lambda_group2 * D.94822;

  D.94822 = &this->value_;
  D.94821 = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::internal::lambda_select1>, sigc::lambda<sigc::internal::lambda_select2> >::operator()<int&, int&, int&> (D.94822, _A_1, _A_2, _A_3);
  return D.94821;
}


typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1, T_arg2>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1, T_arg2) const [with T_arg1 = int; T_arg2 = int&; T_functor = sigc::pointer_functor2<int, int, int>; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1, T_arg2>::type = int] (const struct adaptor_functor * const this, int _A_arg1, int & _A_arg2)
{
  type D.94825;
  struct pointer_functor2 * D.94826;

  D.94826 = &this->functor_;
  D.94825 = sigc::pointer_functor2<int, int, int>::operator() (D.94826, &_A_arg1, _A_arg2);
  return D.94825;
}


sigc::lambda<sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, T_type, typename sigc::unwrap_lambda_type<T_arg>::type> > sigc::static_cast_(const T_arg&) [with T_type = int; T_arg = sigc::lambda<sigc::internal::lambda_select1>; typename sigc::unwrap_lambda_type<T_arg>::type = sigc::internal::lambda_select1] (const struct lambda & a)
{
  struct lambda D.94829;
  struct lambda D.85786;
  struct operator_type D.85785;
  const struct lambda_select1 & D.94830;
  typedef struct operator_type operator_type;

  D.94830 = sigc::unwrap_lambda_value<sigc::internal::lambda_select1> (a);
  sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1>::lambda_operator_convert (&D.85785, D.94830);
  try
    {
      sigc::lambda<sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >::lambda (&D.85786, &D.85785);
      try
        {
          return D.94829;
        }
      finally
        {
          D.85786 = {CLOBBER};
        }
    }
  finally
    {
      D.85785 = {CLOBBER};
    }
}


sigc::lambda_operator_convert<T_action, T_type, T_arg>::lambda_operator_convert(typename sigc::type_trait<T_arg3>::take) [with T_action = sigc::cast_<sigc::static_>; T_type = int; T_arg = sigc::internal::lambda_select1; typename sigc::type_trait<T_arg3>::take = const sigc::internal::lambda_select1&] (struct lambda_operator_convert * const this, const struct lambda_select1 & a)
{
  sigc::lambda_base::lambda_base (this);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1>; typename sigc::type_trait<T_base>::take = const sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1>&] (struct lambda * const this, const struct lambda_operator_convert & v)
{
  struct lambda_core * D.94835;

  D.94835 = &this->D.64429;
  sigc::internal::lambda_core<sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1>, true>::lambda_core (D.94835, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1>] (struct lambda_core * const this, const struct lambda_operator_convert & v)
{
  sigc::lambda_base::lambda_base (this);
}


sigc::lambda<sigc::lambda_group2<T_functor, typename sigc::unwrap_reference<T_arg2>::type, typename sigc::unwrap_reference<T_type2>::type> > sigc::group(const T_functor&, T_type1, T_type2) [with T_functor = int (*)(int, int); T_type1 = sigc::lambda<sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >; T_type2 = int; typename sigc::unwrap_reference<T_type2>::type = int; typename sigc::unwrap_reference<T_arg2>::type = sigc::lambda<sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >] (int (*<Tdd0e>) (int, int) & _A_func, struct lambda _A_1, int _A_2)
{
  struct T_lambda D.87042;
  typedef struct T_lambda T_lambda;

  sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, int>::lambda_group2 (&D.87042, _A_func, &_A_1, &_A_2);
  try
    {
      sigc::lambda<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, int> >::lambda (&<retval>, &D.87042);
      return <retval>;
    }
  finally
    {
      D.87042 = {CLOBBER};
    }
}


sigc::lambda_group2<T_functor, T_type1, T_type2>::lambda_group2(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_functor = int (*)(int, int); T_type1 = sigc::lambda<sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >; T_type2 = int; typename sigc::type_trait<T_base>::take = int (* const&)(int, int); typename sigc::type_trait<T_derived>::take = const sigc::lambda<sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >&; typename sigc::type_trait<T_arg3>::take = const int&] (struct lambda_group2 * const this, int (*<Tdd0e>) (int, int) & _A_func, const struct lambda & _A_1, const int & _A_2)
{
  struct value2_type * D.94840;
  struct functor_type * D.94841;

  sigc::lambda_base::lambda_base (this);
  D.94840 = &this->value2_;
  sigc::lambda<int>::lambda (D.94840, _A_2);
  D.94841 = &this->func_;
  sigc::adaptor_functor<sigc::pointer_functor2<int, int, int> >::adaptor_functor<int (*)(int, int)> (D.94841, _A_func);
}


sigc::lambda<T_type>::lambda(typename sigc::type_trait<T_base>::take) [with T_type = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, int>; typename sigc::type_trait<T_base>::take = const sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, int>&] (struct lambda * const this, const struct lambda_group2 & v)
{
  struct lambda_core * D.94842;

  D.94842 = &this->D.83512;
  sigc::internal::lambda_core<sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, int>, true>::lambda_core (D.94842, v);
}


sigc::internal::lambda_core<T_type, true>::lambda_core(const T_type&) [with T_type = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, int>] (struct lambda_core * const this, const struct lambda_group2 & v)
{
  sigc::lambda_base::lambda_base (this);
  this->value_ = *v;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1) const [with T_arg1 = double; T_type = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, int>; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1>::type = int] (const struct lambda_core * const this, double _A_1)
{
  type D.94843;
  const struct lambda_group2 * D.94844;

  D.94844 = &this->value_;
  D.94843 = sigc::lambda_group2<int (*)(int, int), sigc::lambda<sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, int>::operator()<double&> (D.94844, &_A_1);
  return D.94843;
}


typename sigc::lambda_group2<T_functor, T_type1, T_type2>::deduce_result_type<T_arg1>::type sigc::lambda_group2<T_functor, T_type1, T_type2>::operator()(T_arg1) const [with T_arg1 = double&; T_functor = int (*)(int, int); T_type1 = sigc::lambda<sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >; T_type2 = int; typename sigc::lambda_group2<T_functor, T_type1, T_type2>::deduce_result_type<T_arg1>::type = int] (const struct lambda_group2 * const this, double & _A_1)
{
  type D.94847;
  const struct lambda_core * D.94848;
  int D.94849;
  const struct lambda_core * D.94850;
  int D.94851;
  struct functor_type * D.94852;

  D.94848 = &this->value2_.D.41753;
  D.94849 = sigc::internal::lambda_core<int, false>::operator()<double&> (D.94848, _A_1);
  D.94850 = &this->value1_.D.64429;
  D.94851 = sigc::internal::lambda_core<sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1>, true>::operator()<double&> (D.94850, _A_1);
  D.94852 = &this->func_;
  D.94847 = sigc::adaptor_functor<sigc::pointer_functor2<int, int, int> >::operator()<int, int> (D.94852, D.94851, D.94849);
  return D.94847;
}


sigc::internal::lambda_core<T_type, false>::result_type sigc::internal::lambda_core<T_type, false>::operator()(T_arg1) const [with T_arg1 = double&; T_type = int; sigc::internal::lambda_core<T_type, false>::result_type = int] (const struct lambda_core * const this, double & D.90769)
{
  result_type D.94856;

  D.94856 = this->value_;
  return D.94856;
}


typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1>::type sigc::internal::lambda_core<T_type, true>::operator()(T_arg1) const [with T_arg1 = double&; T_type = sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1>; typename sigc::internal::lambda_core<T_type, true>::deduce_result_type<T_arg1>::type = int] (const struct lambda_core * const this, double & _A_1)
{
  type D.94858;
  const struct lambda_operator_convert * D.94859;

  D.94859 = &this->value_;
  D.94858 = sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1>::operator()<double&> (D.94859, _A_1);
  return D.94858;
}


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

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

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


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

  try
    {
      {

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


sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, std::basic_string<char> > >::~lambda() (struct lambda * const this)
{
  struct lambda_core * D.94864;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.94864 = &this->D.66079;
            sigc::internal::lambda_core<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, std::basic_string<char> >, true>::~lambda_core (D.94864);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.66136>:
}


sigc::internal::lambda_core<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, std::basic_string<char> >, true>::~lambda_core() (struct lambda_core * const this)
{
  struct lambda_operator * D.94866;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.94866 = &this->value_;
            sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::lambda_operator_convert<sigc::cast_<sigc::static_>, int, sigc::internal::lambda_select1> >, std::basic_string<char> >::~lambda_operator (D.94866);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.66131>:
}


sigc::lambda<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> > >::~lambda() (struct lambda * const this)
{
  struct lambda_core * D.94868;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.94868 = &this->D.63393;
            sigc::internal::lambda_core<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> >, true>::~lambda_core (D.94868);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.63491>:
}


sigc::internal::lambda_core<sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> >, true>::~lambda_core() (struct lambda_core * const this)
{
  struct lambda_operator * D.94870;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.94870 = &this->value_;
            sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, sigc::lambda_operator<sigc::bitwise<sigc::leftshift>, std::basic_ostringstream<char>&, sigc::internal::lambda_select1>, std::basic_string<char> >::~lambda_operator (D.94870);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.63486>:
}


{anonymous}::book::~book() (struct book * const this)
{
  struct string * D.94872;
  struct trackable * D.94873;

  {
    try
      {
        try
          {
            try
              {

              }
            finally
              {
                D.94872 = &this->name_;
                std::basic_string<char>::~basic_string (D.94872);
              }
          }
        finally
          {
            D.94873 = &this->D.39605;
            sigc::trackable::~trackable (D.94873);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.68446>:
}


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.83729;
  struct _Rep * D.94876;
  struct _Alloc_hider * D.94877;

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


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

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

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


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

  try
    {
      {

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


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.12;
  struct _Rep & D.94888;
  bool D.94889;
  long int D.94890;
  long int D.94891;
  bool retval.13;
  _Atomic_word * D.94895;
  int D.94896;

  D.94888 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.94889 = D.94888 != this;
  D.94890 = (long int) D.94889;
  D.94891 = __builtin_expect (D.94890, 0);
  retval.12 = D.94891 != 0;
  if (retval.12 != 0) goto <D.94892>; else goto <D.94893>;
  <D.94892>:
  D.94895 = &this->D.11865._M_refcount;
  D.94896 = __gnu_cxx::__exchange_and_add_dispatch (D.94895, -1);
  retval.13 = D.94896 <= 0;
  if (retval.13 != 0) goto <D.94897>; else goto <D.94898>;
  <D.94897>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.94899>;
  <D.94898>:
  <D.94899>:
  goto <D.94900>;
  <D.94893>:
  <D.94900>:
}


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

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


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.14;
  int D.94905;
  _Atomic_word D.94908;

  D.94905 = __gthread_active_p ();
  retval.14 = D.94905 != 0;
  if (retval.14 != 0) goto <D.94906>; else goto <D.94907>;
  <D.94906>:
  D.94908 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.94908;
  <D.94907>:
  D.94908 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.94908;
}


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

  D.94911 = __gthrw___pthread_key_create != 0B;
  D.94910 = (int) D.94911;
  return D.94910;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.94913;
  unsigned int __val.15;
  unsigned int D.94915;

  __val.15 = (unsigned int) __val;
  D.94915 = __atomic_fetch_add_4 (__mem, __val.15, 4);
  D.94913 = (_Atomic_word) D.94915;
  return D.94913;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.94917;
  int D.94918;
  _Atomic_word D.94919;
  _Atomic_word __result;

  __result = *__mem;
  D.94917 = *__mem;
  D.94918 = D.94917 + __val;
  *__mem = D.94918;
  D.94919 = __result;
  return D.94919;
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


sigc::slot<void>::~slot() (struct slot * const this)
{
  struct slot0 * D.94923;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.94923 = &this->D.68395;
            sigc::slot0<void>::~slot0 (D.94923);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.68426>:
}


sigc::slot0<void>::~slot0() (struct slot0 * const this)
{
  struct slot_base * D.94925;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.94925 = &this->D.68353;
            sigc::slot_base::~slot_base (D.94925);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.68421>:
}


(static initializers for test_lambda.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.94927>; else goto <D.94928>;
  <D.94927>:
  if (__priority == 65535) goto <D.94929>; else goto <D.94930>;
  <D.94929>:
  std::ios_base::Init::Init (&__ioinit);
  __cxa_atexit (__comp_dtor , &__ioinit, &__dso_handle);
  std::basic_ostringstream<char>::basic_ostringstream (&result_stream, 16);
  __cxa_atexit (__comp_dtor , &result_stream, &__dso_handle);
  goto <D.94931>;
  <D.94930>:
  <D.94931>:
  goto <D.94932>;
  <D.94928>:
  <D.94932>:
}


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.16;
  const void * * D.94936;
  sizetype iftmp.17;
  int (*__vtbl_ptr_type) () * D.94941;
  int (*__vtbl_ptr_type) () * D.94942;
  long int D.94943;
  struct basic_ios * D.94945;
  int (*__vtbl_ptr_type) () * iftmp.18;
  struct __stringbuf_type * D.94950;
  const void * * iftmp.19;
  struct basic_ostream * D.94955;
  int D.94956;
  struct basic_ios * D.94959;
  int D.94961;

  {
    if (2 == 0) goto <D.94934>; else goto <D.94935>;
    <D.94934>:
    D.94936 = 0B;
    iftmp.16 = *D.94936;
    goto <D.94937>;
    <D.94935>:
    iftmp.16 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
    <D.94937>:
    this->D.22312._vptr.basic_ostream = iftmp.16;
    if (2 == 0) goto <D.94939>; else goto <D.94940>;
    <D.94939>:
    D.94941 = this->D.22312._vptr.basic_ostream;
    D.94942 = D.94941 + 18446744073709551592;
    D.94943 = MEM[(long int *)D.94942];
    iftmp.17 = (sizetype) D.94943;
    goto <D.94944>;
    <D.94940>:
    iftmp.17 = 88;
    <D.94944>:
    D.94945 = this + iftmp.17;
    if (2 == 0) goto <D.94947>; else goto <D.94948>;
    <D.94947>:
    iftmp.18 = MEM[(const void * *)0B + 24B];
    goto <D.94949>;
    <D.94948>:
    iftmp.18 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
    <D.94949>:
    D.94945->D.19008._vptr.ios_base = iftmp.18;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.94950 = &this->_M_stringbuf;
                    std::basic_stringbuf<char>::~basic_stringbuf (D.94950);
                  }
              }
            finally
              {
                if (2 == 0) goto <D.94952>; else goto <D.94953>;
                <D.94952>:
                iftmp.19 = 8B;
                goto <D.94954>;
                <D.94953>:
                iftmp.19 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
                <D.94954>:
                D.94955 = &this->D.22312;
                std::basic_ostream<char>::~basic_ostream (D.94955, iftmp.19);
              }
          }
        finally
          {
            D.94956 = 2;
            if (D.94956 != 0) goto <D.94957>; else goto <D.94958>;
            <D.94957>:
            D.94959 = &this->D.22315;
            std::basic_ios<char>::~basic_ios (D.94959);
            goto <D.94960>;
            <D.94958>:
            <D.94960>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.93168>:
  D.94961 = 0;
  if (D.94961 != 0) goto <D.94962>; else goto <D.94963>;
  <D.94962>:
  operator delete (this);
  goto <D.94964>;
  <D.94963>:
  <D.94964>:
}


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


std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  struct __string_type * D.94974;
  struct basic_streambuf * D.94975;
  int D.94976;

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

              }
            finally
              {
                D.94974 = &this->_M_string;
                std::basic_string<char>::~basic_string (D.94974);
              }
          }
        finally
          {
            D.94975 = &this->D.22162;
            std::basic_streambuf<char>::~basic_streambuf (D.94975);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.83698>:
  D.94976 = 0;
  if (D.94976 != 0) goto <D.94977>; else goto <D.94978>;
  <D.94977>:
  operator delete (this);
  goto <D.94979>;
  <D.94978>:
  <D.94979>:
}


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

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

          }
        finally
          {
            D.94982 = &this->_M_buf_locale;
            std::locale::~locale (D.94982);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.87233>:
  D.94983 = 0;
  if (D.94983 != 0) goto <D.94984>; else goto <D.94985>;
  <D.94984>:
  operator delete (this);
  goto <D.94986>;
  <D.94985>:
  <D.94986>:
}


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


virtual std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  std::basic_stringbuf<char>::~basic_stringbuf (this);
  <D.83702>:
  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.20;
  sizetype iftmp.21;
  int (*__vtbl_ptr_type) () * D.94994;
  int (*__vtbl_ptr_type) () * D.94995;
  long int D.94996;
  struct basic_ios * D.94998;
  int (*__vtbl_ptr_type) () * iftmp.22;
  int D.95003;
  struct basic_ios * D.95006;
  int D.95008;

  {
    if (0 == 0) goto <D.94988>; else goto <D.94989>;
    <D.94988>:
    iftmp.20 = *__vtt_parm;
    goto <D.94990>;
    <D.94989>:
    iftmp.20 = &MEM[(void *)&_ZTVSo + 24B];
    <D.94990>:
    this->_vptr.basic_ostream = iftmp.20;
    if (0 == 0) goto <D.94992>; else goto <D.94993>;
    <D.94992>:
    D.94994 = this->_vptr.basic_ostream;
    D.94995 = D.94994 + 18446744073709551592;
    D.94996 = MEM[(long int *)D.94995];
    iftmp.21 = (sizetype) D.94996;
    goto <D.94997>;
    <D.94993>:
    iftmp.21 = 8;
    <D.94997>:
    D.94998 = this + iftmp.21;
    if (0 == 0) goto <D.95000>; else goto <D.95001>;
    <D.95000>:
    iftmp.22 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.95002>;
    <D.95001>:
    iftmp.22 = &MEM[(void *)&_ZTVSo + 64B];
    <D.95002>:
    D.94998->D.19008._vptr.ios_base = iftmp.22;
    try
      {
        try
          {

          }
        finally
          {
            D.95003 = 0;
            if (D.95003 != 0) goto <D.95004>; else goto <D.95005>;
            <D.95004>:
            D.95006 = &this->D.19694;
            std::basic_ios<char>::~basic_ios (D.95006);
            goto <D.95007>;
            <D.95005>:
            <D.95007>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.87218>:
  D.95008 = 0;
  if (D.95008 != 0) goto <D.95009>; else goto <D.95010>;
  <D.95009>:
  operator delete (this);
  goto <D.95011>;
  <D.95010>:
  <D.95011>:
}


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

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

          }
        finally
          {
            D.95013 = &this->D.19008;
            std::ios_base::~ios_base (D.95013);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.87206>:
  D.95014 = 0;
  if (D.95014 != 0) goto <D.95015>; else goto <D.95016>;
  <D.95015>:
  operator delete (this);
  goto <D.95017>;
  <D.95016>:
  <D.95017>:
}


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.87210>:
  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.95021;
  const void * * iftmp.23;
  struct basic_ostream * D.95027;
  int (*__vtbl_ptr_type) () * iftmp.24;
  const void * * D.95031;
  sizetype iftmp.25;
  int (*__vtbl_ptr_type) () * D.95036;
  int (*__vtbl_ptr_type) () * D.95037;
  long int D.95038;
  struct basic_ios * D.95040;
  int (*__vtbl_ptr_type) () * iftmp.26;
  _Ios_Openmode D.95045;
  struct __stringbuf_type * D.95046;
  struct basic_streambuf * D.95047;
  sizetype iftmp.27;
  struct basic_ios * D.95052;
  const void * * iftmp.28;

  if (1 != 0) goto <D.95019>; else goto <D.95020>;
  <D.95019>:
  D.95021 = &this->D.22315;
  std::basic_ios<char>::basic_ios (D.95021);
  goto <D.95022>;
  <D.95020>:
  <D.95022>:
  try
    {
      if (1 == 0) goto <D.95024>; else goto <D.95025>;
      <D.95024>:
      iftmp.23 = 8B;
      goto <D.95026>;
      <D.95025>:
      iftmp.23 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
      <D.95026>:
      D.95027 = &this->D.22312;
      std::basic_ostream<char>::basic_ostream (D.95027, iftmp.23);
      try
        {
          if (1 == 0) goto <D.95029>; else goto <D.95030>;
          <D.95029>:
          D.95031 = 0B;
          iftmp.24 = *D.95031;
          goto <D.95032>;
          <D.95030>:
          iftmp.24 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
          <D.95032>:
          this->D.22312._vptr.basic_ostream = iftmp.24;
          if (1 == 0) goto <D.95034>; else goto <D.95035>;
          <D.95034>:
          D.95036 = this->D.22312._vptr.basic_ostream;
          D.95037 = D.95036 + 18446744073709551592;
          D.95038 = MEM[(long int *)D.95037];
          iftmp.25 = (sizetype) D.95038;
          goto <D.95039>;
          <D.95035>:
          iftmp.25 = 88;
          <D.95039>:
          D.95040 = this + iftmp.25;
          if (1 == 0) goto <D.95042>; else goto <D.95043>;
          <D.95042>:
          iftmp.26 = MEM[(const void * *)0B + 24B];
          goto <D.95044>;
          <D.95043>:
          iftmp.26 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
          <D.95044>:
          D.95040->D.19008._vptr.ios_base = iftmp.26;
          D.95045 = std::operator| (__mode, 16);
          D.95046 = &this->_M_stringbuf;
          std::basic_stringbuf<char>::basic_stringbuf (D.95046, D.95045);
          try
            {
              D.95047 = &this->_M_stringbuf.D.22162;
              if (1 == 0) goto <D.95049>; else goto <D.95050>;
              <D.95049>:
              D.95036 = this->D.22312._vptr.basic_ostream;
              D.95037 = D.95036 + 18446744073709551592;
              D.95038 = MEM[(long int *)D.95037];
              iftmp.27 = (sizetype) D.95038;
              goto <D.95051>;
              <D.95050>:
              iftmp.27 = 88;
              <D.95051>:
              D.95052 = this + iftmp.27;
              std::basic_ios<char>::init (D.95052, D.95047);
            }
          catch
            {
              D.95046 = &this->_M_stringbuf;
              std::basic_stringbuf<char>::~basic_stringbuf (D.95046);
            }
        }
      catch
        {
          if (1 == 0) goto <D.95054>; else goto <D.95055>;
          <D.95054>:
          iftmp.28 = 8B;
          goto <D.95056>;
          <D.95055>:
          iftmp.28 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
          <D.95056>:
          D.95027 = &this->D.22312;
          std::basic_ostream<char>::~basic_ostream (D.95027, iftmp.28);
        }
    }
  catch
    {
      if (1 != 0) goto <D.95057>; else goto <D.95058>;
      <D.95057>:
      D.95021 = &this->D.22315;
      std::basic_ios<char>::~basic_ios (D.95021);
      goto <D.95059>;
      <D.95058>:
      <D.95059>:
    }
}


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

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


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.95066;
  int (*__vtbl_ptr_type) () * iftmp.29;
  sizetype iftmp.30;
  int (*__vtbl_ptr_type) () * D.95075;
  int (*__vtbl_ptr_type) () * D.95076;
  long int D.95077;
  struct basic_ios * D.95079;
  int (*__vtbl_ptr_type) () * iftmp.31;
  sizetype iftmp.32;
  struct basic_ios * D.95088;

  if (0 != 0) goto <D.95064>; else goto <D.95065>;
  <D.95064>:
  D.95066 = &this->D.19694;
  std::basic_ios<char>::basic_ios (D.95066);
  goto <D.95067>;
  <D.95065>:
  <D.95067>:
  try
    {
      if (0 == 0) goto <D.95069>; else goto <D.95070>;
      <D.95069>:
      iftmp.29 = *__vtt_parm;
      goto <D.95071>;
      <D.95070>:
      iftmp.29 = &MEM[(void *)&_ZTVSo + 24B];
      <D.95071>:
      this->_vptr.basic_ostream = iftmp.29;
      if (0 == 0) goto <D.95073>; else goto <D.95074>;
      <D.95073>:
      D.95075 = this->_vptr.basic_ostream;
      D.95076 = D.95075 + 18446744073709551592;
      D.95077 = MEM[(long int *)D.95076];
      iftmp.30 = (sizetype) D.95077;
      goto <D.95078>;
      <D.95074>:
      iftmp.30 = 8;
      <D.95078>:
      D.95079 = this + iftmp.30;
      if (0 == 0) goto <D.95081>; else goto <D.95082>;
      <D.95081>:
      iftmp.31 = MEM[(const void * *)__vtt_parm + 8B];
      goto <D.95083>;
      <D.95082>:
      iftmp.31 = &MEM[(void *)&_ZTVSo + 64B];
      <D.95083>:
      D.95079->D.19008._vptr.ios_base = iftmp.31;
      if (0 == 0) goto <D.95085>; else goto <D.95086>;
      <D.95085>:
      D.95075 = this->_vptr.basic_ostream;
      D.95076 = D.95075 + 18446744073709551592;
      D.95077 = MEM[(long int *)D.95076];
      iftmp.32 = (sizetype) D.95077;
      goto <D.95087>;
      <D.95086>:
      iftmp.32 = 8;
      <D.95087>:
      D.95088 = this + iftmp.32;
      std::basic_ios<char>::init (D.95088, 0B);
    }
  catch
    {
      if (0 != 0) goto <D.95089>; else goto <D.95090>;
      <D.95089>:
      D.95066 = &this->D.19694;
      std::basic_ios<char>::~basic_ios (D.95066);
      goto <D.95091>;
      <D.95090>:
      <D.95091>:
    }
}


std::_Ios_Openmode std::operator|(std::_Ios_Openmode, std::_Ios_Openmode) (_Ios_Openmode __a, _Ios_Openmode __b)
{
  _Ios_Openmode D.95093;
  int __a.33;
  int __b.34;
  int D.95096;

  __a.33 = (int) __a;
  __b.34 = (int) __b;
  D.95096 = __a.33 | __b.34;
  D.95093 = (_Ios_Openmode) D.95096;
  return D.95093;
}


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.95098;
  struct __string_type * D.95099;

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

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


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

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

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


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.90936;
  struct _Rep & D.95102;
  char * D.95103;
  struct _Alloc_hider * D.95104;

  std::allocator<char>::allocator (&D.90936);
  try
    {
      D.95102 = std::basic_string<char>::_S_empty_rep ();
      D.95103 = std::basic_string<char>::_Rep::_M_refdata (D.95102);
      D.95104 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.95104, D.95103, &D.90936);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.90936);
      D.90936 = {CLOBBER};
    }
  try
    {

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


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

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


_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.95110;
  void * D.95111;

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


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


