int main(int, char**) (int argc, char * * argv)
{
  bool retval.0;
  bool D.48024;
  int D.48027;
  int iftmp.1;
  bool D.48029;
  struct bind_functor D.38176;
  struct foo D.37361;
  int D.48033;
  const struct string D.38226;
  struct allocator D.38225;
  struct bind_functor D.38552;
  struct foo D.38227;
  int D.48034;
  const struct string D.38576;
  struct allocator D.38575;
  struct bind_functor D.38885;
  struct foo D.38577;
  const struct string D.38888;
  struct allocator D.38887;
  struct bind_functor D.39253;
  struct foo D.38889;
  const struct string D.39519;
  struct allocator D.39518;
  struct bind_functor D.39524;
  struct foo D.39520;
  const struct string D.39527;
  struct allocator D.39526;
  struct bind_functor D.39891;
  struct bind_functor D.39529;
  struct foo D.39528;
  const struct string D.39894;
  struct allocator D.39893;
  struct bind_functor D.39896;
  struct foo D.39895;
  const struct string D.40136;
  struct allocator D.40135;
  struct bind_functor D.40951;
  struct foo_void D.40137;
  const struct string D.40954;
  struct allocator D.40953;
  struct bind_functor D.41764;
  int (*<T7902>) (int, int) D.40960;
  const struct string D.41767;
  struct allocator D.41766;
  const struct string D.41771;
  struct allocator D.41770;
  struct bind_functor D.42722;
  struct reference_wrapper D.48035;
  const struct 
{
  struct basic_string & book::<T6c26> (struct book *) * const __pfn;
  long int __delta;
} D.41822;
  struct 
{
  struct string & book::<T6c25> (struct book *) * __pfn;
  long int __delta;
} D.48036;
  struct basic_string & D.48037;
  const struct string D.42725;
  struct allocator D.42724;
  struct bind_functor D.42727;
  struct foo D.42726;
  int D.48038;
  const struct string D.42730;
  struct allocator D.42729;
  struct bind_functor D.43618;
  bool (*<T7fa8>) (bool) D.42735;
  bool D.48039;
  int D.48040;
  const struct string D.43621;
  struct allocator D.43620;
  struct allocator D.43624;
  struct bind_functor D.44586;
  struct reference_wrapper D.48041;
  void (*<T8323>) (struct basic_string &) D.43650;
  struct basic_ostream & D.48042;
  const struct string D.44589;
  struct allocator D.44588;
  const struct string D.44719;
  struct allocator D.44718;
  const struct slot D.45096;
  struct bind_functor D.45083;
  struct reference_wrapper D.48043;
  void (*<T8323>) (struct basic_string &) D.44725;
  struct string & D.48044;
  struct basic_ostream & D.48045;
  const struct string D.45100;
  struct allocator D.45099;
  const struct string D.45103;
  struct allocator D.45102;
  int iftmp.2;
  bool D.48047;

  {
    struct TestUtilities * util;
    struct book test_book;
    struct string str;
    struct slot sl;

    try
      {
        util = TestUtilities::get_instance ();
        D.48024 = TestUtilities::check_command_args (util, argc, argv);
        retval.0 = ~D.48024;
        if (retval.0 != 0) goto <D.48025>; else goto <D.48026>;
        <D.48025>:
        D.48029 = TestUtilities::get_result_and_delete_instance ();
        if (D.48029 != 0) goto <D.48030>; else goto <D.48031>;
        <D.48030>:
        iftmp.1 = 0;
        goto <D.48032>;
        <D.48031>:
        iftmp.1 = 1;
        <D.48032>:
        D.48027 = iftmp.1;
        return D.48027;
        <D.48026>:
        try
          {
            D.38176 = sigc::bind<0, int, {anonymous}::foo> (&D.37361, -12345);
            try
              {
                D.48033 = sigc::bind_functor<0, {anonymous}::foo, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()<int> (&D.38176, 5);
                std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.48033);
              }
            finally
              {
                D.38176 = {CLOBBER};
              }
          }
        finally
          {
            D.37361 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.38225);
        try
          {
            std::basic_string<char>::basic_string (&D.38226, "foo(int -12345, int 5) -12340", &D.38225);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.38226);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.38226);
                D.38226 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.38225);
            D.38225 = {CLOBBER};
          }
        try
          {
            D.38552 = sigc::bind<1, int, {anonymous}::foo> (&D.38227, -12345);
            try
              {
                D.48034 = sigc::bind_functor<1, {anonymous}::foo, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()<int> (&D.38552, 5);
                std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.48034);
              }
            finally
              {
                D.38552 = {CLOBBER};
              }
          }
        finally
          {
            D.38227 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.38575);
        try
          {
            std::basic_string<char>::basic_string (&D.38576, "foo(int 5, int -12345) -12340", &D.38575);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.38576);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.38576);
                D.38576 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.38575);
            D.38575 = {CLOBBER};
          }
        try
          {
            D.38885 = sigc::bind<int, int, {anonymous}::foo> (&D.38577, 1, 2);
            try
              {
                sigc::bind_functor<-1, {anonymous}::foo, int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator() (&D.38885);
              }
            finally
              {
                D.38885 = {CLOBBER};
              }
          }
        finally
          {
            D.38577 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.38887);
        try
          {
            std::basic_string<char>::basic_string (&D.38888, "foo(int 1, int 2) ", &D.38887);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.38888);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.38888);
                D.38888 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.38887);
            D.38887 = {CLOBBER};
          }
        try
          {
            D.39253 = sigc::bind<-1, int, {anonymous}::foo> (&D.38889, 4);
            try
              {
                sigc::bind_functor<-1, {anonymous}::foo, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()<int> (&D.39253, 3);
              }
            finally
              {
                D.39253 = {CLOBBER};
              }
          }
        finally
          {
            D.38889 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.39518);
        try
          {
            std::basic_string<char>::basic_string (&D.39519, "foo(int 3, int 4) ", &D.39518);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.39519);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.39519);
                D.39519 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.39518);
            D.39518 = {CLOBBER};
          }
        try
          {
            D.39524 = sigc::bind<int, {anonymous}::foo> (&D.39520, 4);
            try
              {
                sigc::bind_functor<-1, {anonymous}::foo, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()<int> (&D.39524, 3);
              }
            finally
              {
                D.39524 = {CLOBBER};
              }
          }
        finally
          {
            D.39520 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.39526);
        try
          {
            std::basic_string<char>::basic_string (&D.39527, "foo(int 3, int 4) ", &D.39526);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.39527);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.39527);
                D.39527 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.39526);
            D.39526 = {CLOBBER};
          }
        try
          {
            D.39529 = sigc::bind<0, int, {anonymous}::foo> (&D.39528, 7);
            try
              {
                D.39891 = sigc::bind<0, int, sigc::bind_functor<0, {anonymous}::foo, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.39529, 8);
                try
                  {
                    sigc::bind_functor<0, sigc::bind_functor<0, {anonymous}::foo, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator() (&D.39891);
                  }
                finally
                  {
                    D.39891 = {CLOBBER};
                  }
              }
            finally
              {
                D.39529 = {CLOBBER};
              }
          }
        finally
          {
            D.39528 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.39893);
        try
          {
            std::basic_string<char>::basic_string (&D.39894, "foo(int 7, int 8) ", &D.39893);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.39894);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.39894);
                D.39894 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.39893);
            D.39893 = {CLOBBER};
          }
        try
          {
            D.39896 = sigc::bind<int, int, {anonymous}::foo> (&D.39895, 9, 10);
            try
              {
                sigc::bind_functor<-1, {anonymous}::foo, int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()<int> (&D.39896, 11);
              }
            finally
              {
                D.39896 = {CLOBBER};
              }
          }
        finally
          {
            D.39895 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.40135);
        try
          {
            std::basic_string<char>::basic_string (&D.40136, "foo(int 11, int 9, int 10) ", &D.40135);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.40136);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.40136);
                D.40136 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.40135);
            D.40135 = {CLOBBER};
          }
        try
          {
            D.40951 = sigc::bind<int, {anonymous}::foo_void> (&D.40137, 12);
            try
              {
                sigc::bind_functor<-1, {anonymous}::foo_void, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator() (&D.40951);
              }
            finally
              {
                D.40951 = {CLOBBER};
              }
          }
        finally
          {
            D.40137 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.40953);
        try
          {
            std::basic_string<char>::basic_string (&D.40954, "foo_void(int 12)", &D.40953);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.40954);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.40954);
                D.40954 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.40953);
            D.40953 = {CLOBBER};
          }
        D.40960 = bar;
        try
          {
            D.41764 = sigc::bind<int, int, int (*)(int, int)> (&D.40960, 13, 14); [return slot optimization]
            try
              {
                sigc::bind_functor<-1, int (*)(int, int), int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator() (&D.41764);
              }
            finally
              {
                D.41764 = {CLOBBER};
              }
          }
        finally
          {
            D.40960 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.41766);
        try
          {
            std::basic_string<char>::basic_string (&D.41767, "bar(int 13, int 14) ", &D.41766);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.41767);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.41767);
                D.41767 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.41766);
            D.41766 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.41770);
        try
          {
            std::basic_string<char>::basic_string (&D.41771, "otto", &D.41770);
            try
              {
                {anonymous}::book::book (&test_book, &D.41771);
              }
            finally
              {
                try
                  {
                    std::basic_string<char>::~basic_string (&D.41771);
                  }
                catch
                  {
                    {anonymous}::book::~book (&test_book);
                  }
                D.41771 = {CLOBBER};
              }
          }
        finally
          {
            try
              {
                std::allocator<char>::~allocator (&D.41770);
              }
            catch
              {
                {anonymous}::book::~book (&test_book);
              }
            D.41770 = {CLOBBER};
          }
        try
          {
            D.48035 = sigc::ref<{anonymous}::book> (&test_book);
            D.48036.__pfn = get_name;
            D.48036.__delta = 0;
            D.41822 = D.48036;
            try
              {
                D.42722 = sigc::bind<0, sigc::reference_wrapper<{anonymous}::book>, std::basic_string<char>& ({anonymous}::book::*)()> (&D.41822, D.48035); [return slot optimization]
                try
                  {
                    D.48037 = sigc::bind_functor<0, std::basic_string<char>& ({anonymous}::book::*)(), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator() (&D.42722);
                    std::operator<< <char, std::char_traits<char>, std::allocator<char> > (&result_stream.D.22312, D.48037);
                  }
                finally
                  {
                    D.42722 = {CLOBBER};
                  }
              }
            finally
              {
                D.41822 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.42724);
            try
              {
                std::basic_string<char>::basic_string (&D.42725, "otto", &D.42724);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.42725);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.42725);
                    D.42725 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.42724);
                D.42724 = {CLOBBER};
              }
            try
              {
                D.42727 = sigc::bind<int, {anonymous}::foo> (&D.42726, 15);
                try
                  {
                    D.48038 = sigc::bind_functor<-1, {anonymous}::foo, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator() (&D.42727);
                    std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.48038);
                  }
                finally
                  {
                    D.42727 = {CLOBBER};
                  }
              }
            finally
              {
                D.42726 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.42729);
            try
              {
                std::basic_string<char>::basic_string (&D.42730, "foo(int 15) 1", &D.42729);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.42730);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.42730);
                    D.42730 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.42729);
                D.42729 = {CLOBBER};
              }
            D.42735 = simple;
            try
              {
                D.43618 = sigc::bind<bool, bool (*)(bool)> (&D.42735, 1); [return slot optimization]
                try
                  {
                    D.48039 = sigc::bind_functor<-1, bool (*)(bool), bool, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator() (&D.43618);
                    D.48040 = (int) D.48039;
                    std::basic_ostream<char>::operator<< (&result_stream.D.22312, D.48040);
                  }
                finally
                  {
                    D.43618 = {CLOBBER};
                  }
              }
            finally
              {
                D.42735 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.43620);
            try
              {
                std::basic_string<char>::basic_string (&D.43621, "simple(bool 1) 1", &D.43620);
                try
                  {
                    TestUtilities::check_result (util, &result_stream, &D.43621);
                  }
                finally
                  {
                    std::basic_string<char>::~basic_string (&D.43621);
                    D.43621 = {CLOBBER};
                  }
              }
            finally
              {
                std::allocator<char>::~allocator (&D.43620);
                D.43620 = {CLOBBER};
              }
            std::allocator<char>::allocator (&D.43624);
            try
              {
                std::basic_string<char>::basic_string (&str, "guest book", &D.43624);
              }
            finally
              {
                try
                  {
                    std::allocator<char>::~allocator (&D.43624);
                  }
                catch
                  {
                    std::basic_string<char>::~basic_string (&str);
                  }
                D.43624 = {CLOBBER};
              }
            try
              {
                D.48041 = sigc::ref<std::basic_string<char> > (&str);
                D.43650 = egon;
                try
                  {
                    D.44586 = sigc::bind<sigc::reference_wrapper<std::basic_string<char> >, void (*)(std::basic_string<char>&)> (&D.43650, D.48041); [return slot optimization]
                    try
                      {
                        sigc::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<std::basic_string<char> >, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator() (&D.44586);
                      }
                    finally
                      {
                        D.44586 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.43650 = {CLOBBER};
                  }
                D.48042 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, " ");
                std::operator<< <char, std::char_traits<char>, std::allocator<char> > (D.48042, &str);
                std::allocator<char>::allocator (&D.44588);
                try
                  {
                    std::basic_string<char>::basic_string (&D.44589, "egon(string \'guest book\') egon was here", &D.44588);
                    try
                      {
                        TestUtilities::check_result (util, &result_stream, &D.44589);
                      }
                    finally
                      {
                        std::basic_string<char>::~basic_string (&D.44589);
                        D.44589 = {CLOBBER};
                      }
                  }
                finally
                  {
                    std::allocator<char>::~allocator (&D.44588);
                    D.44588 = {CLOBBER};
                  }
                sigc::slot<void>::slot (&sl);
                try
                  {
                    {
                      struct book guest_book;

                      try
                        {
                          std::allocator<char>::allocator (&D.44718);
                          try
                            {
                              std::basic_string<char>::basic_string (&D.44719, "karl", &D.44718);
                              try
                                {
                                  {anonymous}::book::book (&guest_book, &D.44719);
                                }
                              finally
                                {
                                  try
                                    {
                                      std::basic_string<char>::~basic_string (&D.44719);
                                    }
                                  catch
                                    {
                                      {anonymous}::book::~book (&guest_book);
                                    }
                                  D.44719 = {CLOBBER};
                                }
                            }
                          finally
                            {
                              try
                                {
                                  std::allocator<char>::~allocator (&D.44718);
                                }
                              catch
                                {
                                  {anonymous}::book::~book (&guest_book);
                                }
                              D.44718 = {CLOBBER};
                            }
                          try
                            {
                              D.48043 = sigc::ref<{anonymous}::book> (&guest_book);
                              D.44725 = egon;
                              try
                                {
                                  D.45083 = sigc::bind<sigc::reference_wrapper<{anonymous}::book>, void (*)(std::basic_string<char>&)> (&D.44725, D.48043); [return slot optimization]
                                  try
                                    {
                                      sigc::slot<void>::slot<sigc::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.45096, &D.45083);
                                      try
                                        {
                                          sigc::slot<void>::operator= (&sl, &D.45096);
                                        }
                                      finally
                                        {
                                          sigc::slot<void>::~slot (&D.45096);
                                          D.45096 = {CLOBBER};
                                        }
                                    }
                                  finally
                                    {
                                      D.45083 = {CLOBBER};
                                    }
                                }
                              finally
                                {
                                  D.44725 = {CLOBBER};
                                }
                              sigc::slot0<void>::operator() (&sl.D.44682);
                              D.48044 = {anonymous}::book::operator std::string& (&guest_book);
                              D.48045 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, " ");
                              std::operator<< <char, std::char_traits<char>, std::allocator<char> > (D.48045, D.48044);
                              std::allocator<char>::allocator (&D.45099);
                              try
                                {
                                  std::basic_string<char>::basic_string (&D.45100, "egon(string \'karl\') egon was here", &D.45099);
                                  try
                                    {
                                      TestUtilities::check_result (util, &result_stream, &D.45100);
                                    }
                                  finally
                                    {
                                      std::basic_string<char>::~basic_string (&D.45100);
                                      D.45100 = {CLOBBER};
                                    }
                                }
                              finally
                                {
                                  std::allocator<char>::~allocator (&D.45099);
                                  D.45099 = {CLOBBER};
                                }
                            }
                          finally
                            {
                              {anonymous}::book::~book (&guest_book);
                            }
                        }
                      finally
                        {
                          guest_book = {CLOBBER};
                        }
                    }
                    sigc::slot0<void>::operator() (&sl.D.44682);
                    std::allocator<char>::allocator (&D.45102);
                    try
                      {
                        std::basic_string<char>::basic_string (&D.45103, "", &D.45102);
                        try
                          {
                            TestUtilities::check_result (util, &result_stream, &D.45103);
                          }
                        finally
                          {
                            std::basic_string<char>::~basic_string (&D.45103);
                            D.45103 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        std::allocator<char>::~allocator (&D.45102);
                        D.45102 = {CLOBBER};
                      }
                    D.48047 = TestUtilities::get_result_and_delete_instance ();
                    if (D.48047 != 0) goto <D.48048>; else goto <D.48049>;
                    <D.48048>:
                    iftmp.2 = 0;
                    goto <D.48050>;
                    <D.48049>:
                    iftmp.2 = 1;
                    <D.48050>:
                    D.48027 = iftmp.2;
                    return D.48027;
                  }
                finally
                  {
                    sigc::slot<void>::~slot (&sl);
                  }
              }
            finally
              {
                std::basic_string<char>::~basic_string (&str);
              }
          }
        finally
          {
            {anonymous}::book::~book (&test_book);
          }
      }
    finally
      {
        test_book = {CLOBBER};
        str = {CLOBBER};
        sl = {CLOBBER};
      }
  }
  D.48027 = 0;
  return D.48027;
}


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

  D.48141 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "egon(string \'");
  D.48142 = std::operator<< <char, std::char_traits<char>, std::allocator<char> > (D.48141, str);
  std::operator<< <std::char_traits<char> > (D.48142, "\')");
  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.48145;

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


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.48148;
  long unsigned int D.48149;

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


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

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


bool {anonymous}::simple(bool) (bool test)
{
  int D.48154;
  struct basic_ostream & D.48155;
  struct __ostream_type & D.48156;
  bool D.48157;

  D.48154 = (int) test;
  D.48155 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "simple(bool ");
  D.48156 = std::basic_ostream<char>::operator<< (D.48155, D.48154);
  std::operator<< <std::char_traits<char> > (D.48156, ") ");
  D.48157 = test;
  return D.48157;
}


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

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


int {anonymous}::bar(int, int) (int i, int j)
{
  struct basic_ostream & D.48163;
  struct basic_ostream & D.48164;
  struct basic_ostream & D.48165;
  struct basic_ostream & D.48166;
  int D.48167;

  D.48163 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "bar(int ");
  D.48164 = std::basic_ostream<char>::operator<< (D.48163, i);
  D.48165 = std::operator<< <std::char_traits<char> > (D.48164, ", int ");
  D.48166 = std::basic_ostream<char>::operator<< (D.48165, j);
  std::operator<< <std::char_traits<char> > (D.48166, ") ");
  D.48167 = i + j;
  return D.48167;
}


typename sigc::bind_functor<0, T_functor, T_bound, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::deduce_result_type<T_arg1>::type sigc::bind_functor<0, T_functor, T_bound, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()(T_arg1) [with T_arg1 = int; T_functor = {anonymous}::foo; T_bound = int; typename sigc::bind_functor<0, T_functor, T_bound, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::deduce_result_type<T_arg1>::type = int] (struct bind_functor * const this, int _A_arg1)
{
  type D.48173;
  struct bound_argument * D.48174;
  int & D.48175;
  struct adaptor_type * D.48176;

  D.48174 = &this->bound_;
  D.48175 = sigc::bound_argument<int>::invoke (D.48174);
  D.48176 = &this->D.38173.functor_;
  D.48173 = sigc::adaptor_functor<{anonymous}::foo>::operator()<int&, int&> (D.48176, D.48175, &_A_arg1);
  return D.48173;
}


T_type& sigc::bound_argument<T_type>::invoke() [with T_type = int] (struct bound_argument * const this)
{
  int & D.48179;

  D.48179 = &this->visited_;
  return D.48179;
}


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 = {anonymous}::foo; 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.48181;
  int D.48182;
  int D.48183;
  struct foo * D.48184;

  D.48182 = *_A_arg2;
  D.48183 = *_A_arg1;
  D.48184 = &this->functor_;
  D.48181 = {anonymous}::foo::operator() (D.48184, D.48183, D.48182);
  return D.48181;
}


int {anonymous}::foo::operator()(int, int) (struct foo * const this, int i, int j)
{
  struct basic_ostream & D.48187;
  struct basic_ostream & D.48188;
  struct basic_ostream & D.48189;
  struct basic_ostream & D.48190;
  int D.48191;

  D.48187 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "foo(int ");
  D.48188 = std::basic_ostream<char>::operator<< (D.48187, i);
  D.48189 = std::operator<< <std::char_traits<char> > (D.48188, ", int ");
  D.48190 = std::basic_ostream<char>::operator<< (D.48189, j);
  std::operator<< <std::char_traits<char> > (D.48190, ") ");
  D.48191 = i + j;
  return D.48191;
}


sigc::bind_functor<I_location, T_functor, T_bound1> sigc::bind(const T_functor&, T_bound1) [with int I_location = 1; T_bound1 = int; T_functor = {anonymous}::foo] (const struct foo & _A_func, int _A_b1)
{
  struct bind_functor D.48197;
  struct bind_functor D.45339;

  sigc::bind_functor<1, {anonymous}::foo, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor (&D.45339, _A_func, &_A_b1);
  try
    {
      D.48197 = D.45339;
      return D.48197;
    }
  finally
    {
      D.45339 = {CLOBBER};
    }
}


sigc::bind_functor<1, T_functor, T_bound, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take) [with T_functor = {anonymous}::foo; T_bound = int; typename sigc::type_trait<T_base>::take = const {anonymous}::foo&; typename sigc::type_trait<T_derived>::take = const int&] (struct bind_functor * const this, const struct foo & _A_func, const int & _A_bound)
{
  struct adapts * D.48200;
  struct bound_argument * D.48201;

  D.48200 = &this->D.38549;
  sigc::adapts<{anonymous}::foo>::adapts (D.48200, _A_func);
  D.48201 = &this->bound_;
  sigc::bound_argument<int>::bound_argument (D.48201, _A_bound);
}


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

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


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::adaptor_functor<T_functor>::adaptor_functor(const T_functor&) [with T_functor = {anonymous}::foo] (struct adaptor_functor * const this, const struct foo & _A_functor)
{
  sigc::adaptor_base::adaptor_base (this);
}


sigc::bound_argument<T_type>::bound_argument(const T_type&) [with T_type = int] (struct bound_argument * const this, const int & _A_argument)
{
  int D.48203;

  D.48203 = *_A_argument;
  this->visited_ = D.48203;
}


typename sigc::bind_functor<1, T_functor, T_bound, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::deduce_result_type<T_arg1>::type sigc::bind_functor<1, T_functor, T_bound, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()(T_arg1) [with T_arg1 = int; T_functor = {anonymous}::foo; T_bound = int; typename sigc::bind_functor<1, T_functor, T_bound, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::deduce_result_type<T_arg1>::type = int] (struct bind_functor * const this, int _A_arg1)
{
  type D.48204;
  struct bound_argument * D.48205;
  int & D.48206;
  struct adaptor_type * D.48207;

  D.48205 = &this->bound_;
  D.48206 = sigc::bound_argument<int>::invoke (D.48205);
  D.48207 = &this->D.38549.functor_;
  D.48204 = sigc::adaptor_functor<{anonymous}::foo>::operator()<int&, int&> (D.48207, &_A_arg1, D.48206);
  return D.48204;
}


sigc::bind_functor<-1, T_functor, T_type1, T_type2, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type sigc::bind_functor<-1, T_functor, T_type1, T_type2, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()() [with T_functor = {anonymous}::foo; T_type1 = int; T_type2 = int; sigc::bind_functor<-1, T_functor, T_type1, T_type2, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type = int] (struct bind_functor * const this)
{
  result_type D.48210;
  struct bound_argument * D.48211;
  int & D.48212;
  struct bound_argument * D.48213;
  int & D.48214;
  struct adaptor_type * D.48215;

  D.48211 = &this->bound2_;
  D.48212 = sigc::bound_argument<int>::invoke (D.48211);
  D.48213 = &this->bound1_;
  D.48214 = sigc::bound_argument<int>::invoke (D.48213);
  D.48215 = &this->D.38881.functor_;
  D.48210 = sigc::adaptor_functor<{anonymous}::foo>::operator()<int&, int&> (D.48215, D.48214, D.48212);
  return D.48210;
}


sigc::bind_functor<I_location, T_functor, T_bound1> sigc::bind(const T_functor&, T_bound1) [with int I_location = -1; T_bound1 = int; T_functor = {anonymous}::foo] (const struct foo & _A_func, int _A_b1)
{
  struct bind_functor D.48218;
  struct bind_functor D.45363;

  sigc::bind_functor<-1, {anonymous}::foo, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor (&D.45363, _A_func, &_A_b1);
  try
    {
      D.48218 = D.45363;
      return D.48218;
    }
  finally
    {
      D.45363 = {CLOBBER};
    }
}


sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take) [with T_functor = {anonymous}::foo; T_type1 = int; typename sigc::type_trait<T_base>::take = const {anonymous}::foo&; typename sigc::type_trait<T_derived>::take = const int&] (struct bind_functor * const this, const struct foo & _A_func, const int & _A_bound1)
{
  struct adapts * D.48221;
  struct bound_argument * D.48222;

  D.48221 = &this->D.39250;
  sigc::adapts<{anonymous}::foo>::adapts (D.48221, _A_func);
  D.48222 = &this->bound1_;
  sigc::bound_argument<int>::bound_argument (D.48222, _A_bound1);
}


typename sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::deduce_result_type<T_arg1>::type sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()(T_arg1) [with T_arg1 = int; T_functor = {anonymous}::foo; T_type1 = int; typename sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::deduce_result_type<T_arg1>::type = int] (struct bind_functor * const this, int _A_arg1)
{
  type D.48223;
  struct bound_argument * D.48224;
  int & D.48225;
  struct adaptor_type * D.48226;

  D.48224 = &this->bound1_;
  D.48225 = sigc::bound_argument<int>::invoke (D.48224);
  D.48226 = &this->D.39250.functor_;
  D.48223 = sigc::adaptor_functor<{anonymous}::foo>::operator()<int&, int&> (D.48226, &_A_arg1, D.48225);
  return D.48223;
}


sigc::bind_functor<I_location, T_functor, T_bound1> sigc::bind(const T_functor&, T_bound1) [with int I_location = 0; T_bound1 = int; T_functor = {anonymous}::foo] (const struct foo & _A_func, int _A_b1)
{
  struct bind_functor D.48229;
  struct bind_functor D.45233;

  sigc::bind_functor<0, {anonymous}::foo, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor (&D.45233, _A_func, &_A_b1);
  try
    {
      D.48229 = D.45233;
      return D.48229;
    }
  finally
    {
      D.45233 = {CLOBBER};
    }
}


sigc::bind_functor<0, T_functor, T_bound, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take) [with T_functor = {anonymous}::foo; T_bound = int; typename sigc::type_trait<T_base>::take = const {anonymous}::foo&; typename sigc::type_trait<T_derived>::take = const int&] (struct bind_functor * const this, const struct foo & _A_func, const int & _A_bound)
{
  struct adapts * D.48232;
  struct bound_argument * D.48233;

  D.48232 = &this->D.38173;
  sigc::adapts<{anonymous}::foo>::adapts (D.48232, _A_func);
  D.48233 = &this->bound_;
  sigc::bound_argument<int>::bound_argument (D.48233, _A_bound);
}


sigc::bind_functor<I_location, T_functor, T_bound1> sigc::bind(const T_functor&, T_bound1) [with int I_location = 0; T_bound1 = int; T_functor = sigc::bind_functor<0, {anonymous}::foo, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct bind_functor & _A_func, int _A_b1)
{
  struct bind_functor D.48234;
  struct bind_functor D.45377;

  sigc::bind_functor<0, sigc::bind_functor<0, {anonymous}::foo, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor (&D.45377, _A_func, &_A_b1);
  try
    {
      D.48234 = D.45377;
      return D.48234;
    }
  finally
    {
      D.45377 = {CLOBBER};
    }
}


sigc::bind_functor<0, T_functor, T_bound, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take) [with T_functor = sigc::bind_functor<0, {anonymous}::foo, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_bound = int; typename sigc::type_trait<T_base>::take = const sigc::bind_functor<0, {anonymous}::foo, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&; typename sigc::type_trait<T_derived>::take = const int&] (struct bind_functor * const this, const struct bind_functor & _A_func, const int & _A_bound)
{
  struct adapts * D.48237;
  struct bound_argument * D.48238;

  D.48237 = &this->D.39888;
  sigc::adapts<sigc::bind_functor<0, {anonymous}::foo, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::adapts (D.48237, _A_func);
  D.48238 = &this->bound_;
  sigc::bound_argument<int>::bound_argument (D.48238, _A_bound);
}


sigc::adapts<T_functor>::adapts(const T_functor&) [with T_functor = sigc::bind_functor<0, {anonymous}::foo, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct adapts * const this, const struct bind_functor & _A_functor)
{
  sigc::adaptor_base::adaptor_base (this);
  this->functor_ = *_A_functor;
}


sigc::bind_functor<0, T_functor, T_bound, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type sigc::bind_functor<0, T_functor, T_bound, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()() [with T_functor = sigc::bind_functor<0, {anonymous}::foo, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_bound = int; sigc::bind_functor<0, T_functor, T_bound, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type = int] (struct bind_functor * const this)
{
  result_type D.48239;
  struct bound_argument * D.48240;
  int & D.48241;
  struct adaptor_type * D.48242;

  D.48240 = &this->bound_;
  D.48241 = sigc::bound_argument<int>::invoke (D.48240);
  D.48242 = &this->D.39888.functor_;
  D.48239 = sigc::bind_functor<0, {anonymous}::foo, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()<int&> (D.48242, D.48241);
  return D.48239;
}


typename sigc::bind_functor<0, T_functor, T_bound, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::deduce_result_type<T_arg1>::type sigc::bind_functor<0, T_functor, T_bound, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()(T_arg1) [with T_arg1 = int&; T_functor = {anonymous}::foo; T_bound = int; typename sigc::bind_functor<0, T_functor, T_bound, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::deduce_result_type<T_arg1>::type = int] (struct bind_functor * const this, int & _A_arg1)
{
  type D.48245;
  struct bound_argument * D.48246;
  int & D.48247;
  struct adaptor_type * D.48248;

  D.48246 = &this->bound_;
  D.48247 = sigc::bound_argument<int>::invoke (D.48246);
  D.48248 = &this->D.38173.functor_;
  D.48245 = sigc::adaptor_functor<{anonymous}::foo>::operator()<int&, int&> (D.48248, D.48247, _A_arg1);
  return D.48245;
}


sigc::bind_functor<-1, T_functor, T_type1, T_type2> sigc::bind(const T_functor&, T_type1, T_type2) [with T_type1 = int; T_type2 = int; T_functor = {anonymous}::foo] (const struct foo & _A_func, int _A_b1, int _A_b2)
{
  struct bind_functor D.48251;
  struct bind_functor D.45351;

  sigc::bind_functor<-1, {anonymous}::foo, int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor (&D.45351, _A_func, &_A_b1, &_A_b2);
  try
    {
      D.48251 = D.45351;
      return D.48251;
    }
  finally
    {
      D.45351 = {CLOBBER};
    }
}


sigc::bind_functor<-1, T_functor, T_type1, T_type2, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take, typename sigc::type_trait<T_arg3>::take) [with T_functor = {anonymous}::foo; T_type1 = int; T_type2 = int; typename sigc::type_trait<T_base>::take = const {anonymous}::foo&; typename sigc::type_trait<T_derived>::take = const int&; typename sigc::type_trait<T_arg3>::take = const int&] (struct bind_functor * const this, const struct foo & _A_func, const int & _A_bound1, const int & _A_bound2)
{
  struct adapts * D.48254;
  struct bound_argument * D.48255;
  struct bound_argument * D.48256;

  D.48254 = &this->D.38881;
  sigc::adapts<{anonymous}::foo>::adapts (D.48254, _A_func);
  D.48255 = &this->bound1_;
  sigc::bound_argument<int>::bound_argument (D.48255, _A_bound1);
  D.48256 = &this->bound2_;
  sigc::bound_argument<int>::bound_argument (D.48256, _A_bound2);
}


typename sigc::bind_functor<-1, T_functor, T_type1, T_type2, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::deduce_result_type<T_arg1>::type sigc::bind_functor<-1, T_functor, T_type1, T_type2, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()(T_arg1) [with T_arg1 = int; T_functor = {anonymous}::foo; T_type1 = int; T_type2 = int; typename sigc::bind_functor<-1, T_functor, T_type1, T_type2, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::deduce_result_type<T_arg1>::type = int] (struct bind_functor * const this, int _A_arg1)
{
  type D.48257;
  struct bound_argument * D.48258;
  int & D.48259;
  struct bound_argument * D.48260;
  int & D.48261;
  struct adaptor_type * D.48262;

  D.48258 = &this->bound2_;
  D.48259 = sigc::bound_argument<int>::invoke (D.48258);
  D.48260 = &this->bound1_;
  D.48261 = sigc::bound_argument<int>::invoke (D.48260);
  D.48262 = &this->D.38881.functor_;
  D.48257 = sigc::adaptor_functor<{anonymous}::foo>::operator()<int&, int&, int&> (D.48262, &_A_arg1, D.48261, D.48259);
  return D.48257;
}


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 = int&; T_arg2 = int&; T_arg3 = int&; T_functor = {anonymous}::foo; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1, T_arg2, T_arg3>::type = int] (const struct adaptor_functor * const this, int & _A_arg1, int & _A_arg2, int & _A_arg3)
{
  type D.48265;
  int D.48266;
  int D.48267;
  int D.48268;
  struct foo * D.48269;

  D.48266 = *_A_arg3;
  D.48267 = *_A_arg2;
  D.48268 = *_A_arg1;
  D.48269 = &this->functor_;
  D.48265 = {anonymous}::foo::operator() (D.48269, D.48268, D.48267, D.48266);
  return D.48265;
}


int {anonymous}::foo::operator()(int, int, int) (struct foo * const this, int i, int j, int k)
{
  struct basic_ostream & D.48272;
  struct basic_ostream & D.48273;
  struct basic_ostream & D.48274;
  struct basic_ostream & D.48275;
  struct basic_ostream & D.48276;
  struct basic_ostream & D.48277;
  int D.48278;

  D.48272 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "foo(int ");
  D.48273 = std::basic_ostream<char>::operator<< (D.48272, i);
  D.48274 = std::operator<< <std::char_traits<char> > (D.48273, ", int ");
  D.48275 = std::basic_ostream<char>::operator<< (D.48274, j);
  D.48276 = std::operator<< <std::char_traits<char> > (D.48275, ", int ");
  D.48277 = std::basic_ostream<char>::operator<< (D.48276, k);
  std::operator<< <std::char_traits<char> > (D.48277, ") ");
  D.48278 = 0;
  return D.48278;
}


sigc::bind_functor<-1, T_functor, T_type1> sigc::bind(const T_functor&, T_type1) [with T_type1 = int; T_functor = {anonymous}::foo_void] (const struct foo_void & _A_func, int _A_b1)
{
  struct bind_functor D.48286;
  struct bind_functor D.45567;

  sigc::bind_functor<-1, {anonymous}::foo_void, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor (&D.45567, _A_func, &_A_b1);
  try
    {
      D.48286 = D.45567;
      return D.48286;
    }
  finally
    {
      D.45567 = {CLOBBER};
    }
}


sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take) [with T_functor = {anonymous}::foo_void; T_type1 = int; typename sigc::type_trait<T_base>::take = const {anonymous}::foo_void&; typename sigc::type_trait<T_derived>::take = const int&] (struct bind_functor * const this, const struct foo_void & _A_func, const int & _A_bound1)
{
  struct adapts * D.48289;
  struct bound_argument * D.48290;

  D.48289 = &this->D.40948;
  sigc::adapts<{anonymous}::foo_void>::adapts (D.48289, _A_func);
  D.48290 = &this->bound1_;
  sigc::bound_argument<int>::bound_argument (D.48290, _A_bound1);
}


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

  sigc::adaptor_base::adaptor_base (this);
  D.48291 = &this->functor_;
  sigc::adaptor_functor<{anonymous}::foo_void>::adaptor_functor (D.48291, _A_functor);
}


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


sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()() [with T_functor = {anonymous}::foo_void; T_type1 = int; sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type = void] (struct bind_functor * const this)
{
  struct bound_argument * D.48292;
  int & D.48293;
  struct adaptor_type * D.48294;

  D.48292 = &this->bound1_;
  D.48293 = sigc::bound_argument<int>::invoke (D.48292);
  D.48294 = &this->D.40948.functor_;
  sigc::adaptor_functor<{anonymous}::foo_void>::operator()<int&> (D.48294, D.48293);
  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 = {anonymous}::foo_void; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type = void] (const struct adaptor_functor * const this, int & _A_arg1)
{
  int D.48296;
  struct foo_void * D.48297;

  D.48296 = *_A_arg1;
  D.48297 = &this->functor_;
  {anonymous}::foo_void::operator() (D.48297, D.48296);
  return;
}


void {anonymous}::foo_void::operator()(int) (struct foo_void * const this, int i)
{
  struct basic_ostream & D.48299;
  struct basic_ostream & D.48300;

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


sigc::bind_functor<-1, T_functor, T_type1, T_type2> sigc::bind(const T_functor&, T_type1, T_type2) [with T_type1 = int; T_type2 = int; T_functor = int (*)(int, int)] (int (*<T7902>) (int, int) & _A_func, int _A_b1, int _A_b2)
{
  sigc::bind_functor<-1, int (*)(int, int), int, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor (&<retval>, _A_func, &_A_b1, &_A_b2);
  return <retval>;
}


sigc::bind_functor<-1, T_functor, T_type1, T_type2, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor(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 bind_functor * const this, int (*<T7902>) (int, int) & _A_func, const int & _A_bound1, const int & _A_bound2)
{
  struct adapts * D.48305;
  struct bound_argument * D.48306;
  struct bound_argument * D.48307;

  D.48305 = &this->D.41760;
  sigc::adapts<int (*)(int, int)>::adapts (D.48305, _A_func);
  D.48306 = &this->bound1_;
  sigc::bound_argument<int>::bound_argument (D.48306, _A_bound1);
  D.48307 = &this->bound2_;
  sigc::bound_argument<int>::bound_argument (D.48307, _A_bound2);
}


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

  sigc::adaptor_base::adaptor_base (this);
  D.48308 = &this->functor_;
  sigc::adaptor_functor<sigc::pointer_functor2<int, int, int> >::adaptor_functor<int (*)(int, int)> (D.48308, _A_functor);
}


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 (*<T7902>) (int, int) & _A_type)
{
  int (*<T7900>) (int, int) D.48309;
  struct pointer_functor2 * D.48310;

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


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::bind_functor<-1, T_functor, T_type1, T_type2, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type sigc::bind_functor<-1, T_functor, T_type1, T_type2, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()() [with T_functor = int (*)(int, int); T_type1 = int; T_type2 = int; sigc::bind_functor<-1, T_functor, T_type1, T_type2, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type = int] (struct bind_functor * const this)
{
  result_type D.48311;
  struct bound_argument * D.48312;
  int & D.48313;
  struct bound_argument * D.48314;
  int & D.48315;
  struct adaptor_type * D.48316;

  D.48312 = &this->bound2_;
  D.48313 = sigc::bound_argument<int>::invoke (D.48312);
  D.48314 = &this->bound1_;
  D.48315 = sigc::bound_argument<int>::invoke (D.48314);
  D.48316 = &this->D.41760.functor_;
  D.48311 = sigc::adaptor_functor<sigc::pointer_functor2<int, int, int> >::operator()<int&, int&> (D.48316, D.48315, D.48313);
  return D.48311;
}


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.48319;
  struct pointer_functor2 * D.48320;

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


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.48323;
  int (*<T7900>) (int, int) D.48324;
  int D.48325;
  int D.48326;

  D.48324 = this->func_ptr_;
  D.48325 = *_A_a2;
  D.48326 = *_A_a1;
  D.48323 = D.48324 (D.48326, D.48325);
  return D.48323;
}


sigc::bind_functor<I_location, T_functor, T_bound1> sigc::bind(const T_functor&, T_bound1) [with int I_location = 0; T_bound1 = sigc::reference_wrapper<{anonymous}::book>; T_functor = std::basic_string<char>& ({anonymous}::book::*)()] (const struct 
{
  struct basic_string & book::<T6c26> (struct book *) * const __pfn;
  long int __delta;
} & _A_func, struct reference_wrapper _A_b1)
{
  sigc::bind_functor<0, std::basic_string<char>& ({anonymous}::book::*)(), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor (&<retval>, _A_func, &_A_b1);
  return <retval>;
}


sigc::bind_functor<0, T_functor, T_bound, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take) [with T_functor = std::basic_string<char>& ({anonymous}::book::*)(); T_bound = sigc::reference_wrapper<{anonymous}::book>; typename sigc::type_trait<T_base>::take = std::basic_string<char>& ({anonymous}::book::* const&)(); typename sigc::type_trait<T_derived>::take = const sigc::reference_wrapper<{anonymous}::book>&] (struct bind_functor * const this, const struct 
{
  struct basic_string & book::<T6c26> (struct book *) * const __pfn;
  long int __delta;
} & _A_func, const struct reference_wrapper & _A_bound)
{
  struct adapts * D.48331;
  struct bound_argument * D.48332;

  D.48331 = &this->D.42719;
  sigc::adapts<std::basic_string<char>& ({anonymous}::book::*)()>::adapts (D.48331, _A_func);
  D.48332 = &this->bound_;
  sigc::bound_argument<sigc::reference_wrapper<{anonymous}::book> >::bound_argument (D.48332, _A_bound);
}


sigc::adapts<T_functor>::adapts(const T_functor&) [with T_functor = std::basic_string<char>& ({anonymous}::book::*)()] (struct adapts * const this, const struct 
{
  struct basic_string & book::<T6c26> (struct book *) * const __pfn;
  long int __delta;
} & _A_functor)
{
  struct adaptor_type * D.48333;

  sigc::adaptor_base::adaptor_base (this);
  D.48333 = &this->functor_;
  sigc::adaptor_functor<sigc::mem_functor0<std::basic_string<char>&, {anonymous}::book> >::adaptor_functor<std::basic_string<char>& ({anonymous}::book::*)()> (D.48333, _A_functor);
}


sigc::adaptor_functor<T_functor>::adaptor_functor(const T_type&) [with T_type = std::basic_string<char>& ({anonymous}::book::*)(); T_functor = sigc::mem_functor0<std::basic_string<char>&, {anonymous}::book>] (struct adaptor_functor * const this, const struct 
{
  struct basic_string & book::<T6c26> (struct book *) * const __pfn;
  long int __delta;
} & _A_type)
{
  struct mem_functor0 * D.48334;

  sigc::adaptor_base::adaptor_base (this);
  D.48334 = &this->functor_;
  sigc::mem_functor0<std::basic_string<char>&, {anonymous}::book>::mem_functor0 (D.48334, *_A_type);
}


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


sigc::bound_argument<sigc::reference_wrapper<T_type> >::bound_argument(const sigc::reference_wrapper<T_type>&) [with T_wrapped = {anonymous}::book] (struct bound_argument * const this, const struct reference_wrapper & _A_argument)
{
  struct book & D.48335;
  struct limit_reference * D.48336;

  D.48335 = sigc::unwrap<{anonymous}::book> (_A_argument);
  D.48336 = &this->visited_;
  sigc::limit_reference<{anonymous}::book, true>::limit_reference (D.48336, D.48335);
}


T_type& sigc::unwrap(const sigc::reference_wrapper<T_type>&) [with T_type = {anonymous}::book] (const struct reference_wrapper & v)
{
  struct book & D.48338;

  D.48338 = sigc::reference_wrapper<{anonymous}::book>::operator {anonymous}::book& (v);
  return D.48338;
}


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

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


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

  D.48342 = &_A_target->D.37348;
  this->visited = D.48342;
  this->invoked = _A_target;
}


sigc::bind_functor<0, T_functor, T_bound, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type sigc::bind_functor<0, T_functor, T_bound, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()() [with T_functor = std::basic_string<char>& ({anonymous}::book::*)(); T_bound = sigc::reference_wrapper<{anonymous}::book>; sigc::bind_functor<0, T_functor, T_bound, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type = std::basic_string<char>&] (struct bind_functor * const this)
{
  struct basic_string & D.48343;
  struct bound_argument * D.48344;
  struct book & D.48345;
  struct adaptor_type * D.48346;

  D.48344 = &this->bound_;
  D.48345 = sigc::bound_argument<sigc::reference_wrapper<{anonymous}::book> >::invoke (D.48344);
  D.48346 = &this->D.42719.functor_;
  D.48343 = sigc::adaptor_functor<sigc::mem_functor0<std::basic_string<char>&, {anonymous}::book> >::operator()<{anonymous}::book&> (D.48346, D.48345);
  return D.48343;
}


T_wrapped& sigc::bound_argument<sigc::reference_wrapper<T_type> >::invoke() [with T_wrapped = {anonymous}::book] (struct bound_argument * const this)
{
  struct book & D.48350;
  struct limit_reference * D.48351;

  D.48351 = &this->visited_;
  D.48350 = sigc::limit_reference<{anonymous}::book, true>::invoke (D.48351);
  return D.48350;
}


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

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


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::mem_functor0<std::basic_string<char>&, {anonymous}::book>; typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type = std::basic_string<char>&] (const struct adaptor_functor * const this, struct book & _A_arg1)
{
  struct basic_string & D.48355;
  struct mem_functor0 * D.48356;

  D.48356 = &this->functor_;
  D.48355 = sigc::mem_functor0<std::basic_string<char>&, {anonymous}::book>::operator() (D.48356, _A_arg1);
  return D.48355;
}


T_return sigc::mem_functor0<T_return, T_obj>::operator()(T_obj&) const [with T_return = std::basic_string<char>&; T_obj = {anonymous}::book] (const struct mem_functor0 * const this, struct book & _A_obj)
{
  struct basic_string & D.48359;
  struct basic_string & book::<T6c26> (struct book *) * iftmp.3;
  struct basic_string & book::<T6c26> (struct book *) * D.48361;
  long int D.48362;
  long int D.48363;
  long int D.48367;
  sizetype D.48368;
  struct book * D.48369;
  int (*__vtbl_ptr_type) () * D.48370;
  long int D.48371;
  sizetype D.48372;
  int (*__vtbl_ptr_type) () * D.48373;

  D.48361 = this->func_ptr_.__pfn;
  D.48362 = (long int) D.48361;
  D.48363 = D.48362 & 1;
  if (D.48363 == 0) goto <D.48364>; else goto <D.48365>;
  <D.48364>:
  iftmp.3 = this->func_ptr_.__pfn;
  goto <D.48366>;
  <D.48365>:
  D.48367 = this->func_ptr_.__delta;
  D.48368 = (sizetype) D.48367;
  D.48369 = _A_obj + D.48368;
  D.48370 = MEM[(int (*__vtbl_ptr_type) () * *)D.48369];
  D.48361 = this->func_ptr_.__pfn;
  D.48362 = (long int) D.48361;
  D.48371 = D.48362 + -1;
  D.48372 = (sizetype) D.48371;
  D.48373 = D.48370 + D.48372;
  iftmp.3 = *D.48373;
  <D.48366>:
  D.48367 = this->func_ptr_.__delta;
  D.48368 = (sizetype) D.48367;
  D.48369 = _A_obj + D.48368;
  D.48359 = iftmp.3 (D.48369);
  return D.48359;
}


sigc::bind_functor<-1, T_functor, T_type1> sigc::bind(const T_functor&, T_type1) [with T_type1 = int; T_functor = {anonymous}::foo] (const struct foo & _A_func, int _A_b1)
{
  struct bind_functor D.48376;
  struct bind_functor D.45366;

  sigc::bind_functor<-1, {anonymous}::foo, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor (&D.45366, _A_func, &_A_b1);
  try
    {
      D.48376 = D.45366;
      return D.48376;
    }
  finally
    {
      D.45366 = {CLOBBER};
    }
}


sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()() [with T_functor = {anonymous}::foo; T_type1 = int; sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type = int] (struct bind_functor * const this)
{
  result_type D.48379;
  struct bound_argument * D.48380;
  int & D.48381;
  struct adaptor_type * D.48382;

  D.48380 = &this->bound1_;
  D.48381 = sigc::bound_argument<int>::invoke (D.48380);
  D.48382 = &this->D.39250.functor_;
  D.48379 = sigc::adaptor_functor<{anonymous}::foo>::operator()<int&> (D.48382, D.48381);
  return D.48379;
}


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

  D.48386 = *_A_arg1;
  D.48387 = &this->functor_;
  D.48385 = {anonymous}::foo::operator() (D.48387, D.48386);
  return D.48385;
}


int {anonymous}::foo::operator()(int) (struct foo * const this, int i)
{
  struct basic_ostream & D.48390;
  struct basic_ostream & D.48391;
  int D.48392;
  bool D.48393;

  D.48390 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "foo(int ");
  D.48391 = std::basic_ostream<char>::operator<< (D.48390, i);
  std::operator<< <std::char_traits<char> > (D.48391, ") ");
  D.48393 = i > 0;
  D.48392 = (int) D.48393;
  return D.48392;
}


sigc::bind_functor<-1, T_functor, T_type1> sigc::bind(const T_functor&, T_type1) [with T_type1 = bool; T_functor = bool (*)(bool)] (bool (*<T7fa8>) (bool) & _A_func, bool _A_b1)
{
  sigc::bind_functor<-1, bool (*)(bool), bool, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor (&<retval>, _A_func, &_A_b1);
  return <retval>;
}


sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take) [with T_functor = bool (*)(bool); T_type1 = bool; typename sigc::type_trait<T_base>::take = bool (* const&)(bool); typename sigc::type_trait<T_derived>::take = const bool&] (struct bind_functor * const this, bool (*<T7fa8>) (bool) & _A_func, const bool & _A_bound1)
{
  struct adapts * D.48399;
  struct bound_argument * D.48400;

  D.48399 = &this->D.43615;
  sigc::adapts<bool (*)(bool)>::adapts (D.48399, _A_func);
  D.48400 = &this->bound1_;
  sigc::bound_argument<bool>::bound_argument (D.48400, _A_bound1);
}


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

  sigc::adaptor_base::adaptor_base (this);
  D.48401 = &this->functor_;
  sigc::adaptor_functor<sigc::pointer_functor1<bool, bool> >::adaptor_functor<bool (*)(bool)> (D.48401, _A_functor);
}


sigc::adaptor_functor<T_functor>::adaptor_functor(const T_type&) [with T_type = bool (*)(bool); T_functor = sigc::pointer_functor1<bool, bool>] (struct adaptor_functor * const this, bool (*<T7fa8>) (bool) & _A_type)
{
  bool (*<T7fa6>) (bool) D.48402;
  struct pointer_functor1 * D.48403;

  sigc::adaptor_base::adaptor_base (this);
  D.48402 = *_A_type;
  D.48403 = &this->functor_;
  sigc::pointer_functor1<bool, bool>::pointer_functor1 (D.48403, D.48402);
}


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


sigc::bound_argument<T_type>::bound_argument(const T_type&) [with T_type = bool] (struct bound_argument * const this, const bool & _A_argument)
{
  bool D.48404;

  D.48404 = *_A_argument;
  this->visited_ = D.48404;
}


sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()() [with T_functor = bool (*)(bool); T_type1 = bool; sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type = bool] (struct bind_functor * const this)
{
  result_type D.48405;
  struct bound_argument * D.48406;
  bool & D.48407;
  struct adaptor_type * D.48408;

  D.48406 = &this->bound1_;
  D.48407 = sigc::bound_argument<bool>::invoke (D.48406);
  D.48408 = &this->D.43615.functor_;
  D.48405 = sigc::adaptor_functor<sigc::pointer_functor1<bool, bool> >::operator()<bool&> (D.48408, D.48407);
  return D.48405;
}


T_type& sigc::bound_argument<T_type>::invoke() [with T_type = bool] (struct bound_argument * const this)
{
  bool & D.48411;

  D.48411 = &this->visited_;
  return D.48411;
}


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

  D.48414 = &this->functor_;
  D.48413 = sigc::pointer_functor1<bool, bool>::operator() (D.48414, _A_arg1);
  return D.48413;
}


T_return sigc::pointer_functor1<T_arg1, T_return>::operator()(typename sigc::type_trait<T_base>::take) const [with T_arg1 = bool; T_return = bool; typename sigc::type_trait<T_base>::take = const bool&] (const struct pointer_functor1 * const this, const bool & _A_a1)
{
  bool D.48417;
  bool (*<T7fa6>) (bool) D.48418;
  bool D.48419;
  int D.48420;

  D.48418 = this->func_ptr_;
  D.48419 = *_A_a1;
  D.48420 = (int) D.48419;
  D.48417 = D.48418 (D.48420);
  return D.48417;
}


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

  D.48424 = (int) __n;
  D.48423 = std::basic_ostream<char>::_M_insert<bool> (this, D.48424);
  return D.48423;
}


sigc::reference_wrapper<T_type> sigc::ref(T_type&) [with T_type = std::basic_string<char>] (struct basic_string & v)
{
  struct reference_wrapper D.48429;
  struct reference_wrapper D.46253;

  sigc::reference_wrapper<std::basic_string<char> >::reference_wrapper (&D.46253, v);
  try
    {
      D.48429 = D.46253;
      return D.48429;
    }
  finally
    {
      D.46253 = {CLOBBER};
    }
}


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


sigc::bind_functor<-1, T_functor, T_type1> sigc::bind(const T_functor&, T_type1) [with T_type1 = sigc::reference_wrapper<std::basic_string<char> >; T_functor = void (*)(std::basic_string<char>&)] (void (*<T8323>) (struct basic_string &) & _A_func, struct reference_wrapper _A_b1)
{
  sigc::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<std::basic_string<char> >, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor (&<retval>, _A_func, &_A_b1);
  return <retval>;
}


sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take) [with T_functor = void (*)(std::basic_string<char>&); T_type1 = sigc::reference_wrapper<std::basic_string<char> >; typename sigc::type_trait<T_base>::take = void (* const&)(std::basic_string<char>&); typename sigc::type_trait<T_derived>::take = const sigc::reference_wrapper<std::basic_string<char> >&] (struct bind_functor * const this, void (*<T8323>) (struct basic_string &) & _A_func, const struct reference_wrapper & _A_bound1)
{
  struct adapts * D.48434;
  struct bound_argument * D.48435;

  D.48434 = &this->D.44583;
  sigc::adapts<void (*)(std::basic_string<char>&)>::adapts (D.48434, _A_func);
  D.48435 = &this->bound1_;
  sigc::bound_argument<sigc::reference_wrapper<std::basic_string<char> > >::bound_argument (D.48435, _A_bound1);
}


sigc::adapts<T_functor>::adapts(const T_functor&) [with T_functor = void (*)(std::basic_string<char>&)] (struct adapts * const this, void (*<T8323>) (struct basic_string &) & _A_functor)
{
  struct adaptor_type * D.48436;

  sigc::adaptor_base::adaptor_base (this);
  D.48436 = &this->functor_;
  sigc::adaptor_functor<sigc::pointer_functor1<std::basic_string<char>&, void> >::adaptor_functor<void (*)(std::basic_string<char>&)> (D.48436, _A_functor);
}


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 (*<T8323>) (struct basic_string &) & _A_type)
{
  void (*<T830c>) (struct basic_string &) D.48437;
  struct pointer_functor1 * D.48438;

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


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::bound_argument<sigc::reference_wrapper<T_type> >::bound_argument(const sigc::reference_wrapper<T_type>&) [with T_wrapped = std::basic_string<char>] (struct bound_argument * const this, const struct reference_wrapper & _A_argument)
{
  struct basic_string & D.48439;
  struct limit_reference * D.48440;

  D.48439 = sigc::unwrap<std::basic_string<char> > (_A_argument);
  D.48440 = &this->visited_;
  sigc::limit_reference<std::basic_string<char>, false>::limit_reference (D.48440, D.48439);
}


T_type& sigc::unwrap(const sigc::reference_wrapper<T_type>&) [with T_type = std::basic_string<char>] (const struct reference_wrapper & v)
{
  struct basic_string & D.48442;

  D.48442 = sigc::reference_wrapper<std::basic_string<char> >::operator std::basic_string<char>& (v);
  return D.48442;
}


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

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


sigc::limit_reference<T_type, I_derives_trackable>::limit_reference(T_type&) [with T_type = std::basic_string<char>; bool I_derives_trackable = false] (struct limit_reference * const this, struct basic_string & _A_target)
{
  this->visited = _A_target;
}


sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()() [with T_functor = void (*)(std::basic_string<char>&); T_type1 = sigc::reference_wrapper<std::basic_string<char> >; sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type = void] (struct bind_functor * const this)
{
  struct bound_argument * D.48446;
  struct basic_string & D.48447;
  struct adaptor_type * D.48448;

  D.48446 = &this->bound1_;
  D.48447 = sigc::bound_argument<sigc::reference_wrapper<std::basic_string<char> > >::invoke (D.48446);
  D.48448 = &this->D.44583.functor_;
  sigc::adaptor_functor<sigc::pointer_functor1<std::basic_string<char>&, void> >::operator()<std::basic_string<char>&> (D.48448, D.48447);
  return;
}


T_wrapped& sigc::bound_argument<sigc::reference_wrapper<T_type> >::invoke() [with T_wrapped = std::basic_string<char>] (struct bound_argument * const this)
{
  struct basic_string & D.48451;
  struct limit_reference * D.48452;

  D.48452 = &this->visited_;
  D.48451 = sigc::limit_reference<std::basic_string<char>, false>::invoke (D.48452);
  return D.48451;
}


T_type& sigc::limit_reference<T_type, I_derives_trackable>::invoke() const [with T_type = std::basic_string<char>; bool I_derives_trackable = false] (const struct limit_reference * const this)
{
  struct basic_string & D.48454;

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


typename sigc::adaptor_functor<T_functor>::deduce_result_type<T_arg1>::type sigc::adaptor_functor<T_functor>::operator()(T_arg1) const [with T_arg1 = std::basic_string<char>&; T_functor = sigc::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 basic_string & _A_arg1)
{
  struct pointer_functor1 * D.48456;

  D.48456 = &this->functor_;
  sigc::pointer_functor1<std::basic_string<char>&, void>::operator() (D.48456, _A_arg1);
  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 (*<T830c>) (struct basic_string &) D.48458;

  D.48458 = this->func_ptr_;
  D.48458 (_A_a1);
  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.48460;

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

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


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

  D.48461 = &this->D.44640;
  sigc::slot_base::slot_base (D.48461);
  try
    {

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


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

  D.48462 = &this->D.37348;
  sigc::trackable::trackable (D.48462);
  try
    {
      D.48463 = &this->name_;
      std::basic_string<char>::basic_string (D.48463, name);
      try
        {

        }
      catch
        {
          D.48463 = &this->name_;
          std::basic_string<char>::~basic_string (D.48463);
        }
    }
  catch
    {
      D.48462 = &this->D.37348;
      sigc::trackable::~trackable (D.48462);
    }
}


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

  sigc::reference_wrapper<{anonymous}::book>::reference_wrapper (&D.45822, v);
  try
    {
      D.48465 = D.45822;
      return D.48465;
    }
  finally
    {
      D.45822 = {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::bind_functor<-1, T_functor, T_type1> sigc::bind(const T_functor&, T_type1) [with T_type1 = sigc::reference_wrapper<{anonymous}::book>; T_functor = void (*)(std::basic_string<char>&)] (void (*<T8323>) (struct basic_string &) & _A_func, struct reference_wrapper _A_b1)
{
  sigc::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor (&<retval>, _A_func, &_A_b1);
  return <retval>;
}


sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::bind_functor(typename sigc::type_trait<T_base>::take, typename sigc::type_trait<T_derived>::take) [with T_functor = void (*)(std::basic_string<char>&); T_type1 = sigc::reference_wrapper<{anonymous}::book>; typename sigc::type_trait<T_base>::take = void (* const&)(std::basic_string<char>&); typename sigc::type_trait<T_derived>::take = const sigc::reference_wrapper<{anonymous}::book>&] (struct bind_functor * const this, void (*<T8323>) (struct basic_string &) & _A_func, const struct reference_wrapper & _A_bound1)
{
  struct adapts * D.48470;
  struct bound_argument * D.48471;

  D.48470 = &this->D.45080;
  sigc::adapts<void (*)(std::basic_string<char>&)>::adapts (D.48470, _A_func);
  D.48471 = &this->bound1_;
  sigc::bound_argument<sigc::reference_wrapper<{anonymous}::book> >::bound_argument (D.48471, _A_bound1);
}


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::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = void] (struct slot * const this, const struct bind_functor & _A_func)
{
  struct slot0 * D.48472;

  D.48472 = &this->D.44682;
  sigc::slot0<void>::slot0<sigc::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (D.48472, _A_func);
  try
    {

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


sigc::slot0<T_return>::slot0(const T_functor&) [with T_functor = sigc::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = void] (struct slot0 * const this, const struct bind_functor & _A_func)
{
  void * D.46810;
  struct slot_base * D.48473;
  struct rep_type * D.48474;
  void * (*<T1711>) (void *) D.48475;

  D.46810 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::typed_slot_rep (D.46810, _A_func);
    }
  catch
    {
      operator delete (D.46810);
    }
  D.48473 = &this->D.44640;
  sigc::slot_base::slot_base (D.48473, D.46810);
  try
    {
      D.48474 = this->D.44640.rep_;
      D.48475 = sigc::internal::slot_call0<sigc::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, void>::address ();
      D.48474->call_ = D.48475;
    }
  catch
    {
      D.48473 = &this->D.44640;
      sigc::slot_base::~slot_base (D.48473);
    }
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const T_functor&) [with T_functor = sigc::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct typed_slot_rep * const this, const struct bind_functor & functor)
{
  struct slot_rep * D.48478;
  struct adaptor_type * D.48479;
  struct slot_do_bind D.47162;

  D.48478 = &this->D.46799;
  sigc::internal::slot_rep::slot_rep (D.48478, 0B, destroy, dup);
  try
    {
      this->functor_ = *functor;
      D.48479 = &this->functor_;
      D.48478 = &this->D.46799;
      sigc::internal::slot_do_bind::slot_do_bind (&D.47162, D.48478);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.47162, D.48479);
        }
      finally
        {
          D.47162 = {CLOBBER};
        }
    }
  catch
    {
      D.48478 = &this->D.46799;
      sigc::internal::slot_rep::~slot_rep (D.48478);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::dup(void*) [with T_functor = sigc::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (void * data)
{
  void * D.48482;
  void * D.47307;
  struct slot_rep * a_rep;

  a_rep = data;
  D.47307 = operator new (88);
  try
    {
      sigc::internal::typed_slot_rep<sigc::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::typed_slot_rep (D.47307, a_rep);
    }
  catch
    {
      operator delete (D.47307);
    }
  D.48482 = D.47307;
  return D.48482;
}


sigc::internal::typed_slot_rep<T_functor>::typed_slot_rep(const sigc::internal::typed_slot_rep<T_functor>&) [with T_functor = sigc::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (struct typed_slot_rep * const this, const struct typed_slot_rep & cl)
{
  void * (*<T1711>) (void *) D.48486;
  struct slot_rep * D.48487;
  struct adaptor_type * D.48488;
  struct slot_do_bind D.47413;

  D.48486 = cl->D.46799.call_;
  D.48487 = &this->D.46799;
  sigc::internal::slot_rep::slot_rep (D.48487, D.48486, destroy, dup);
  try
    {
      this->functor_ = cl->functor_;
      D.48488 = &this->functor_;
      D.48487 = &this->D.46799;
      sigc::internal::slot_do_bind::slot_do_bind (&D.47413, D.48487);
      try
        {
          sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_bind, sigc::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.47413, D.48488);
        }
      finally
        {
          D.47413 = {CLOBBER};
        }
    }
  catch
    {
      D.48487 = &this->D.46799;
      sigc::internal::slot_rep::~slot_rep (D.48487);
    }
}


static void* sigc::internal::typed_slot_rep<T_functor>::destroy(void*) [with T_functor = sigc::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (void * data)
{
  struct adaptor_type * D.48491;
  struct slot_do_unbind D.47292;
  void * D.48492;
  struct self * self_;

  self_ = data;
  self_->D.46799.call_ = 0B;
  self_->D.46799.destroy_ = 0B;
  D.48491 = &self_->functor_;
  sigc::internal::slot_do_unbind::slot_do_unbind (&D.47292, self_);
  try
    {
      sigc::visit_each_type<sigc::trackable*, sigc::internal::slot_do_unbind, sigc::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&D.47292, D.48491);
    }
  finally
    {
      D.47292 = {CLOBBER};
    }
  D.48492 = 0B;
  return D.48492;
}


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::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct slot_do_unbind & _A_action, const struct bind_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::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


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


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


static void sigc::visitor<sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::do_visit_each(const T_action&, const sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_functor = void (*)(std::basic_string<char>&); T_type1 = sigc::reference_wrapper<{anonymous}::book>] (const struct limit_derived_target & _A_action, const struct bind_functor & _A_target)
{
  struct adaptor_type * D.48496;
  const struct bound_argument * D.48497;

  D.48496 = &_A_target->D.45080.functor_;
  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.48496);
  D.48497 = &_A_target->bound1_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::bound_argument<sigc::reference_wrapper<{anonymous}::book> > > (_A_action, D.48497);
}


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

  D.48498 = &_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.48498);
}


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.47742, const struct limit_derived_target & D.47743)
{
  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::bound_argument<sigc::reference_wrapper<{anonymous}::book> >] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_functor)
{
  sigc::visitor<sigc::bound_argument<sigc::reference_wrapper<{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::bound_argument<T_type> >::do_visit_each(const T_action&, const sigc::bound_argument<T_type>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>; T_type = sigc::reference_wrapper<{anonymous}::book>] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_argument)
{
  const struct limit_reference & D.48499;

  D.48499 = sigc::bound_argument<sigc::reference_wrapper<{anonymous}::book> >::visit (_A_argument);
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_unbind>, sigc::limit_reference<{anonymous}::book, true> > (_A_action, D.48499);
}


const sigc::limit_reference<T_wrapped>& sigc::bound_argument<sigc::reference_wrapper<T_type> >::visit() const [with T_wrapped = {anonymous}::book] (const struct bound_argument * const this)
{
  const struct limit_reference & D.48500;

  D.48500 = &this->visited_;
  return D.48500;
}


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


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

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


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

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


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


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


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


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

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


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

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


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

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


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::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct slot_do_bind & _A_action, const struct bind_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::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (&limited_action, _A_functor);
    }
  finally
    {
      limited_action = {CLOBBER};
    }
}


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


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


static void sigc::visitor<sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::do_visit_each(const T_action&, const sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_functor = void (*)(std::basic_string<char>&); T_type1 = sigc::reference_wrapper<{anonymous}::book>] (const struct limit_derived_target & _A_action, const struct bind_functor & _A_target)
{
  struct adaptor_type * D.48509;
  const struct bound_argument * D.48510;

  D.48509 = &_A_target->D.45080.functor_;
  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.48509);
  D.48510 = &_A_target->bound1_;
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::bound_argument<sigc::reference_wrapper<{anonymous}::book> > > (_A_action, D.48510);
}


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

  D.48511 = &_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.48511);
}


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.47716, const struct limit_derived_target & D.47717)
{
  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::bound_argument<sigc::reference_wrapper<{anonymous}::book> >] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_functor)
{
  sigc::visitor<sigc::bound_argument<sigc::reference_wrapper<{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::bound_argument<T_type> >::do_visit_each(const T_action&, const sigc::bound_argument<T_type>&) [with T_action = sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>; T_type = sigc::reference_wrapper<{anonymous}::book>] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_argument)
{
  const struct limit_reference & D.48512;

  D.48512 = sigc::bound_argument<sigc::reference_wrapper<{anonymous}::book> >::visit (_A_argument);
  sigc::visit_each<sigc::internal::limit_derived_target<sigc::trackable*, sigc::internal::slot_do_bind>, sigc::limit_reference<{anonymous}::book, true> > (_A_action, D.48512);
}


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


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

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


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


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


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


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

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


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

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


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

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


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

  D.48519 = this->destroy_;
  if (D.48519 != 0B) goto <D.48520>; else goto <D.48521>;
  <D.48520>:
  D.48519 = this->destroy_;
  D.48519 (this);
  goto <D.48522>;
  <D.48521>:
  <D.48522>:
}


static void* (* sigc::internal::slot_call0<T_functor, T_return>::address())(void*) [with T_functor = sigc::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = void; sigc::internal::hook = void* (*)(void*)] ()
{
  void * (*hook) (void *) D.48523;

  D.48523 = call_it;
  return D.48523;
}


static T_return sigc::internal::slot_call0<T_functor, T_return>::call_it(sigc::internal::slot_rep*) [with T_functor = sigc::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_return = void] (struct slot_rep * rep)
{
  struct adaptor_type * D.48525;
  typedef struct typed_slot typed_slot;
  struct typed_slot * typed_rep;

  typed_rep = rep;
  D.48525 = &typed_rep->functor_;
  sigc::bind_functor<-1, void (*)(std::basic_string<char>&), sigc::reference_wrapper<{anonymous}::book>, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator() (D.48525);
  return;
}


sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::operator()() [with T_functor = void (*)(std::basic_string<char>&); T_type1 = sigc::reference_wrapper<{anonymous}::book>; sigc::bind_functor<-1, T_functor, T_type1, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>::result_type = void] (struct bind_functor * const this)
{
  struct bound_argument * D.48527;
  struct book & D.48528;
  struct adaptor_type * D.48529;

  D.48527 = &this->bound1_;
  D.48528 = sigc::bound_argument<sigc::reference_wrapper<{anonymous}::book> >::invoke (D.48527);
  D.48529 = &this->D.45080.functor_;
  sigc::adaptor_functor<sigc::pointer_functor1<std::basic_string<char>&, void> >::operator()<{anonymous}::book&> (D.48529, D.48528);
  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 = {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 & _A_arg1)
{
  struct string & D.48532;
  struct pointer_functor1 * D.48533;

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


sigc::slot<void>& sigc::slot<void>::operator=(const sigc::slot<void>&) (struct slot * const this, const struct slot & D.45085)
{
  const struct slot0 * D.48535;
  struct slot0 * D.48536;
  struct slot & D.48537;

  D.48535 = &D.45085->D.44682;
  D.48536 = &this->D.44682;
  sigc::slot0<void>::operator= (D.48536, D.48535);
  D.48537 = this;
  return D.48537;
}


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.48539;
  struct slot_base * D.48540;
  struct slot0 & D.48541;

  D.48539 = &src->D.44640;
  D.48540 = &this->D.44640;
  sigc::slot_base::operator= (D.48540, D.48539);
  D.48541 = this;
  return D.48541;
}


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

  D.48543 = {anonymous}::book::get_name (this);
  return D.48543;
}


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.48547;
  int (*__vtbl_ptr_type) () * D.48548;
  long int D.48549;
  sizetype D.48550;
  struct basic_ios * D.48551;
  long unsigned int D.48553;
  long int D.48554;
  struct basic_ostream & D.48555;

  if (__s == 0B) goto <D.48545>; else goto <D.48546>;
  <D.48545>:
  D.48547 = __out->_vptr.basic_ostream;
  D.48548 = D.48547 + 18446744073709551592;
  D.48549 = MEM[(long int *)D.48548];
  D.48550 = (sizetype) D.48549;
  D.48551 = __out + D.48550;
  std::basic_ios<char>::setstate (D.48551, 1);
  goto <D.48552>;
  <D.48546>:
  D.48553 = std::char_traits<char>::length (__s);
  D.48554 = (long int) D.48553;
  std::__ostream_insert<char, std::char_traits<char> > (__out, __s, D.48554);
  <D.48552>:
  D.48555 = __out;
  return D.48555;
}


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.48557;
  _Ios_Iostate D.48558;

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


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

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


std::_Ios_Iostate std::operator|(std::_Ios_Iostate, std::_Ios_Iostate) (_Ios_Iostate __a, _Ios_Iostate __b)
{
  _Ios_Iostate D.48562;
  int __a.4;
  int __b.5;
  int D.48565;

  __a.4 = (int) __a;
  __b.5 = (int) __b;
  D.48565 = __a.4 | __b.5;
  D.48562 = (_Ios_Iostate) D.48565;
  return D.48562;
}


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.48567;
  long unsigned int D.48568;
  long int D.48569;
  const char * D.48570;

  D.48568 = std::basic_string<char>::size (__str);
  D.48569 = (long int) D.48568;
  D.48570 = std::basic_string<char>::data (__str);
  D.48567 = std::__ostream_insert<char, std::char_traits<char> > (__os, D.48570, D.48569);
  return D.48567;
}


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.48575;
  struct _Rep * D.48576;

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


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.48579;
  char * D.48580;

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


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

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


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

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


T_return sigc::slot0<T_return>::operator()() const [with T_return = void] (const struct slot0 * const this)
{
  bool retval.6;
  bool iftmp.7;
  const struct slot_base * D.48592;
  bool D.48593;
  bool D.48594;
  bool D.48596;
  bool D.48597;
  struct rep_type * D.48601;
  void * (*<T1711>) (void *) D.48602;

  D.48592 = &this->D.44640;
  D.48593 = sigc::slot_base::empty (D.48592);
  D.48594 = ~D.48593;
  if (D.48594 != 0) goto <D.48595>; else goto <D.48590>;
  <D.48595>:
  D.48592 = &this->D.44640;
  D.48596 = sigc::slot_base::blocked (D.48592);
  D.48597 = ~D.48596;
  if (D.48597 != 0) goto <D.48598>; else goto <D.48590>;
  <D.48598>:
  iftmp.7 = 1;
  goto <D.48591>;
  <D.48590>:
  iftmp.7 = 0;
  <D.48591>:
  retval.6 = iftmp.7;
  if (retval.6 != 0) goto <D.48599>; else goto <D.48600>;
  <D.48599>:
  D.48601 = this->D.44640.rep_;
  D.48602 = D.48601->call_;
  D.48601 = this->D.44640.rep_;
  D.48602 (D.48601);
  return;
  <D.48600>:
  return;
}


bool sigc::slot_base::empty() const (const struct slot_base * const this)
{
  bool D.48604;
  bool iftmp.8;
  struct rep_type * D.48609;
  void * (*<T1711>) (void *) D.48611;

  D.48609 = this->rep_;
  if (D.48609 == 0B) goto <D.48606>; else goto <D.48610>;
  <D.48610>:
  D.48609 = this->rep_;
  D.48611 = D.48609->call_;
  if (D.48611 == 0B) goto <D.48606>; else goto <D.48607>;
  <D.48606>:
  iftmp.8 = 1;
  goto <D.48608>;
  <D.48607>:
  iftmp.8 = 0;
  <D.48608>:
  D.48604 = iftmp.8;
  return D.48604;
}


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

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


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

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

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


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

  try
    {
      {

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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


sigc::slot<void>::~slot() (struct slot * const this)
{
  struct slot0 * D.48619;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.48619 = &this->D.44682;
            sigc::slot0<void>::~slot0 (D.48619);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.44713>:
}


sigc::slot0<void>::~slot0() (struct slot0 * const this)
{
  struct slot_base * D.48621;

  {
    try
      {
        try
          {

          }
        finally
          {
            D.48621 = &this->D.44640;
            sigc::slot_base::~slot_base (D.48621);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.44708>:
}


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.45219;
  struct _Rep * D.48623;
  struct _Alloc_hider * D.48624;

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


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

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

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


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

  try
    {
      {

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


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.9;
  struct _Rep & D.48635;
  bool D.48636;
  long int D.48637;
  long int D.48638;
  bool retval.10;
  _Atomic_word * D.48642;
  int D.48643;

  D.48635 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.48636 = D.48635 != this;
  D.48637 = (long int) D.48636;
  D.48638 = __builtin_expect (D.48637, 0);
  retval.9 = D.48638 != 0;
  if (retval.9 != 0) goto <D.48639>; else goto <D.48640>;
  <D.48639>:
  D.48642 = &this->D.11865._M_refcount;
  D.48643 = __gnu_cxx::__exchange_and_add_dispatch (D.48642, -1);
  retval.10 = D.48643 <= 0;
  if (retval.10 != 0) goto <D.48644>; else goto <D.48645>;
  <D.48644>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.48646>;
  <D.48645>:
  <D.48646>:
  goto <D.48647>;
  <D.48640>:
  <D.48647>:
}


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

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


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.11;
  int D.48652;
  _Atomic_word D.48655;

  D.48652 = __gthread_active_p ();
  retval.11 = D.48652 != 0;
  if (retval.11 != 0) goto <D.48653>; else goto <D.48654>;
  <D.48653>:
  D.48655 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.48655;
  <D.48654>:
  D.48655 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.48655;
}


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

  D.48658 = __gthrw___pthread_key_create != 0B;
  D.48657 = (int) D.48658;
  return D.48657;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.48660;
  unsigned int __val.12;
  unsigned int D.48662;

  __val.12 = (unsigned int) __val;
  D.48662 = __atomic_fetch_add_4 (__mem, __val.12, 4);
  D.48660 = (_Atomic_word) D.48662;
  return D.48660;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.48664;
  int D.48665;
  _Atomic_word D.48666;
  _Atomic_word __result;

  __result = *__mem;
  D.48664 = *__mem;
  D.48665 = D.48664 + __val;
  *__mem = D.48665;
  D.48666 = __result;
  return D.48666;
}


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


{anonymous}::book::~book() (struct book * const this)
{
  struct string * D.48668;
  struct trackable * D.48669;

  {
    try
      {
        try
          {
            try
              {

              }
            finally
              {
                D.48668 = &this->name_;
                std::basic_string<char>::~basic_string (D.48668);
              }
          }
        finally
          {
            D.48669 = &this->D.37348;
            sigc::trackable::~trackable (D.48669);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.41785>:
}


(static initializers for test_bind.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.48672>; else goto <D.48673>;
  <D.48672>:
  if (__priority == 65535) goto <D.48674>; else goto <D.48675>;
  <D.48674>:
  std::basic_ostringstream<char>::basic_ostringstream (&result_stream, 16);
  __cxa_atexit (__comp_dtor , &result_stream, &__dso_handle);
  goto <D.48676>;
  <D.48675>:
  <D.48676>:
  goto <D.48677>;
  <D.48673>:
  <D.48677>:
}


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.13;
  const void * * D.48681;
  sizetype iftmp.14;
  int (*__vtbl_ptr_type) () * D.48686;
  int (*__vtbl_ptr_type) () * D.48687;
  long int D.48688;
  struct basic_ios * D.48690;
  int (*__vtbl_ptr_type) () * iftmp.15;
  struct __stringbuf_type * D.48695;
  const void * * iftmp.16;
  struct basic_ostream * D.48700;
  int D.48701;
  struct basic_ios * D.48704;
  int D.48706;

  {
    if (2 == 0) goto <D.48679>; else goto <D.48680>;
    <D.48679>:
    D.48681 = 0B;
    iftmp.13 = *D.48681;
    goto <D.48682>;
    <D.48680>:
    iftmp.13 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
    <D.48682>:
    this->D.22312._vptr.basic_ostream = iftmp.13;
    if (2 == 0) goto <D.48684>; else goto <D.48685>;
    <D.48684>:
    D.48686 = this->D.22312._vptr.basic_ostream;
    D.48687 = D.48686 + 18446744073709551592;
    D.48688 = MEM[(long int *)D.48687];
    iftmp.14 = (sizetype) D.48688;
    goto <D.48689>;
    <D.48685>:
    iftmp.14 = 88;
    <D.48689>:
    D.48690 = this + iftmp.14;
    if (2 == 0) goto <D.48692>; else goto <D.48693>;
    <D.48692>:
    iftmp.15 = MEM[(const void * *)0B + 24B];
    goto <D.48694>;
    <D.48693>:
    iftmp.15 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
    <D.48694>:
    D.48690->D.19008._vptr.ios_base = iftmp.15;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.48695 = &this->_M_stringbuf;
                    std::basic_stringbuf<char>::~basic_stringbuf (D.48695);
                  }
              }
            finally
              {
                if (2 == 0) goto <D.48697>; else goto <D.48698>;
                <D.48697>:
                iftmp.16 = 8B;
                goto <D.48699>;
                <D.48698>:
                iftmp.16 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
                <D.48699>:
                D.48700 = &this->D.22312;
                std::basic_ostream<char>::~basic_ostream (D.48700, iftmp.16);
              }
          }
        finally
          {
            D.48701 = 2;
            if (D.48701 != 0) goto <D.48702>; else goto <D.48703>;
            <D.48702>:
            D.48704 = &this->D.22315;
            std::basic_ios<char>::~basic_ios (D.48704);
            goto <D.48705>;
            <D.48703>:
            <D.48705>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.47802>:
  D.48706 = 0;
  if (D.48706 != 0) goto <D.48707>; else goto <D.48708>;
  <D.48707>:
  operator delete (this);
  goto <D.48709>;
  <D.48708>:
  <D.48709>:
}


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


std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  struct __string_type * D.48719;
  struct basic_streambuf * D.48720;
  int D.48721;

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

              }
            finally
              {
                D.48719 = &this->_M_string;
                std::basic_string<char>::~basic_string (D.48719);
              }
          }
        finally
          {
            D.48720 = &this->D.22162;
            std::basic_streambuf<char>::~basic_streambuf (D.48720);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.45187>:
  D.48721 = 0;
  if (D.48721 != 0) goto <D.48722>; else goto <D.48723>;
  <D.48722>:
  operator delete (this);
  goto <D.48724>;
  <D.48723>:
  <D.48724>:
}


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

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

          }
        finally
          {
            D.48727 = &this->_M_buf_locale;
            std::locale::~locale (D.48727);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.46493>:
  D.48728 = 0;
  if (D.48728 != 0) goto <D.48729>; else goto <D.48730>;
  <D.48729>:
  operator delete (this);
  goto <D.48731>;
  <D.48730>:
  <D.48731>:
}


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


virtual std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  std::basic_stringbuf<char>::~basic_stringbuf (this);
  <D.45191>:
  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.17;
  sizetype iftmp.18;
  int (*__vtbl_ptr_type) () * D.48739;
  int (*__vtbl_ptr_type) () * D.48740;
  long int D.48741;
  struct basic_ios * D.48743;
  int (*__vtbl_ptr_type) () * iftmp.19;
  int D.48748;
  struct basic_ios * D.48751;
  int D.48753;

  {
    if (0 == 0) goto <D.48733>; else goto <D.48734>;
    <D.48733>:
    iftmp.17 = *__vtt_parm;
    goto <D.48735>;
    <D.48734>:
    iftmp.17 = &MEM[(void *)&_ZTVSo + 24B];
    <D.48735>:
    this->_vptr.basic_ostream = iftmp.17;
    if (0 == 0) goto <D.48737>; else goto <D.48738>;
    <D.48737>:
    D.48739 = this->_vptr.basic_ostream;
    D.48740 = D.48739 + 18446744073709551592;
    D.48741 = MEM[(long int *)D.48740];
    iftmp.18 = (sizetype) D.48741;
    goto <D.48742>;
    <D.48738>:
    iftmp.18 = 8;
    <D.48742>:
    D.48743 = this + iftmp.18;
    if (0 == 0) goto <D.48745>; else goto <D.48746>;
    <D.48745>:
    iftmp.19 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.48747>;
    <D.48746>:
    iftmp.19 = &MEM[(void *)&_ZTVSo + 64B];
    <D.48747>:
    D.48743->D.19008._vptr.ios_base = iftmp.19;
    try
      {
        try
          {

          }
        finally
          {
            D.48748 = 0;
            if (D.48748 != 0) goto <D.48749>; else goto <D.48750>;
            <D.48749>:
            D.48751 = &this->D.19694;
            std::basic_ios<char>::~basic_ios (D.48751);
            goto <D.48752>;
            <D.48750>:
            <D.48752>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.46478>:
  D.48753 = 0;
  if (D.48753 != 0) goto <D.48754>; else goto <D.48755>;
  <D.48754>:
  operator delete (this);
  goto <D.48756>;
  <D.48755>:
  <D.48756>:
}


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

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

          }
        finally
          {
            D.48758 = &this->D.19008;
            std::ios_base::~ios_base (D.48758);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.46466>:
  D.48759 = 0;
  if (D.48759 != 0) goto <D.48760>; else goto <D.48761>;
  <D.48760>:
  operator delete (this);
  goto <D.48762>;
  <D.48761>:
  <D.48762>:
}


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.46470>:
  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.48766;
  const void * * iftmp.20;
  struct basic_ostream * D.48772;
  int (*__vtbl_ptr_type) () * iftmp.21;
  const void * * D.48776;
  sizetype iftmp.22;
  int (*__vtbl_ptr_type) () * D.48781;
  int (*__vtbl_ptr_type) () * D.48782;
  long int D.48783;
  struct basic_ios * D.48785;
  int (*__vtbl_ptr_type) () * iftmp.23;
  _Ios_Openmode D.48790;
  struct __stringbuf_type * D.48791;
  struct basic_streambuf * D.48792;
  sizetype iftmp.24;
  struct basic_ios * D.48797;
  const void * * iftmp.25;

  if (1 != 0) goto <D.48764>; else goto <D.48765>;
  <D.48764>:
  D.48766 = &this->D.22315;
  std::basic_ios<char>::basic_ios (D.48766);
  goto <D.48767>;
  <D.48765>:
  <D.48767>:
  try
    {
      if (1 == 0) goto <D.48769>; else goto <D.48770>;
      <D.48769>:
      iftmp.20 = 8B;
      goto <D.48771>;
      <D.48770>:
      iftmp.20 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
      <D.48771>:
      D.48772 = &this->D.22312;
      std::basic_ostream<char>::basic_ostream (D.48772, iftmp.20);
      try
        {
          if (1 == 0) goto <D.48774>; else goto <D.48775>;
          <D.48774>:
          D.48776 = 0B;
          iftmp.21 = *D.48776;
          goto <D.48777>;
          <D.48775>:
          iftmp.21 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
          <D.48777>:
          this->D.22312._vptr.basic_ostream = iftmp.21;
          if (1 == 0) goto <D.48779>; else goto <D.48780>;
          <D.48779>:
          D.48781 = this->D.22312._vptr.basic_ostream;
          D.48782 = D.48781 + 18446744073709551592;
          D.48783 = MEM[(long int *)D.48782];
          iftmp.22 = (sizetype) D.48783;
          goto <D.48784>;
          <D.48780>:
          iftmp.22 = 88;
          <D.48784>:
          D.48785 = this + iftmp.22;
          if (1 == 0) goto <D.48787>; else goto <D.48788>;
          <D.48787>:
          iftmp.23 = MEM[(const void * *)0B + 24B];
          goto <D.48789>;
          <D.48788>:
          iftmp.23 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
          <D.48789>:
          D.48785->D.19008._vptr.ios_base = iftmp.23;
          D.48790 = std::operator| (__mode, 16);
          D.48791 = &this->_M_stringbuf;
          std::basic_stringbuf<char>::basic_stringbuf (D.48791, D.48790);
          try
            {
              D.48792 = &this->_M_stringbuf.D.22162;
              if (1 == 0) goto <D.48794>; else goto <D.48795>;
              <D.48794>:
              D.48781 = this->D.22312._vptr.basic_ostream;
              D.48782 = D.48781 + 18446744073709551592;
              D.48783 = MEM[(long int *)D.48782];
              iftmp.24 = (sizetype) D.48783;
              goto <D.48796>;
              <D.48795>:
              iftmp.24 = 88;
              <D.48796>:
              D.48797 = this + iftmp.24;
              std::basic_ios<char>::init (D.48797, D.48792);
            }
          catch
            {
              D.48791 = &this->_M_stringbuf;
              std::basic_stringbuf<char>::~basic_stringbuf (D.48791);
            }
        }
      catch
        {
          if (1 == 0) goto <D.48799>; else goto <D.48800>;
          <D.48799>:
          iftmp.25 = 8B;
          goto <D.48801>;
          <D.48800>:
          iftmp.25 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
          <D.48801>:
          D.48772 = &this->D.22312;
          std::basic_ostream<char>::~basic_ostream (D.48772, iftmp.25);
        }
    }
  catch
    {
      if (1 != 0) goto <D.48802>; else goto <D.48803>;
      <D.48802>:
      D.48766 = &this->D.22315;
      std::basic_ios<char>::~basic_ios (D.48766);
      goto <D.48804>;
      <D.48803>:
      <D.48804>:
    }
}


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

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


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.48811;
  int (*__vtbl_ptr_type) () * iftmp.26;
  sizetype iftmp.27;
  int (*__vtbl_ptr_type) () * D.48820;
  int (*__vtbl_ptr_type) () * D.48821;
  long int D.48822;
  struct basic_ios * D.48824;
  int (*__vtbl_ptr_type) () * iftmp.28;
  sizetype iftmp.29;
  struct basic_ios * D.48833;

  if (0 != 0) goto <D.48809>; else goto <D.48810>;
  <D.48809>:
  D.48811 = &this->D.19694;
  std::basic_ios<char>::basic_ios (D.48811);
  goto <D.48812>;
  <D.48810>:
  <D.48812>:
  try
    {
      if (0 == 0) goto <D.48814>; else goto <D.48815>;
      <D.48814>:
      iftmp.26 = *__vtt_parm;
      goto <D.48816>;
      <D.48815>:
      iftmp.26 = &MEM[(void *)&_ZTVSo + 24B];
      <D.48816>:
      this->_vptr.basic_ostream = iftmp.26;
      if (0 == 0) goto <D.48818>; else goto <D.48819>;
      <D.48818>:
      D.48820 = this->_vptr.basic_ostream;
      D.48821 = D.48820 + 18446744073709551592;
      D.48822 = MEM[(long int *)D.48821];
      iftmp.27 = (sizetype) D.48822;
      goto <D.48823>;
      <D.48819>:
      iftmp.27 = 8;
      <D.48823>:
      D.48824 = this + iftmp.27;
      if (0 == 0) goto <D.48826>; else goto <D.48827>;
      <D.48826>:
      iftmp.28 = MEM[(const void * *)__vtt_parm + 8B];
      goto <D.48828>;
      <D.48827>:
      iftmp.28 = &MEM[(void *)&_ZTVSo + 64B];
      <D.48828>:
      D.48824->D.19008._vptr.ios_base = iftmp.28;
      if (0 == 0) goto <D.48830>; else goto <D.48831>;
      <D.48830>:
      D.48820 = this->_vptr.basic_ostream;
      D.48821 = D.48820 + 18446744073709551592;
      D.48822 = MEM[(long int *)D.48821];
      iftmp.29 = (sizetype) D.48822;
      goto <D.48832>;
      <D.48831>:
      iftmp.29 = 8;
      <D.48832>:
      D.48833 = this + iftmp.29;
      std::basic_ios<char>::init (D.48833, 0B);
    }
  catch
    {
      if (0 != 0) goto <D.48834>; else goto <D.48835>;
      <D.48834>:
      D.48811 = &this->D.19694;
      std::basic_ios<char>::~basic_ios (D.48811);
      goto <D.48836>;
      <D.48835>:
      <D.48836>:
    }
}


std::_Ios_Openmode std::operator|(std::_Ios_Openmode, std::_Ios_Openmode) (_Ios_Openmode __a, _Ios_Openmode __b)
{
  _Ios_Openmode D.48838;
  int __a.30;
  int __b.31;
  int D.48841;

  __a.30 = (int) __a;
  __b.31 = (int) __b;
  D.48841 = __a.30 | __b.31;
  D.48838 = (_Ios_Openmode) D.48841;
  return D.48838;
}


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.48843;
  struct __string_type * D.48844;

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

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


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

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

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


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.46879;
  struct _Rep & D.48847;
  char * D.48848;
  struct _Alloc_hider * D.48849;

  std::allocator<char>::allocator (&D.46879);
  try
    {
      D.48847 = std::basic_string<char>::_S_empty_rep ();
      D.48848 = std::basic_string<char>::_Rep::_M_refdata (D.48847);
      D.48849 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.48849, D.48848, &D.46879);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.46879);
      D.46879 = {CLOBBER};
    }
  try
    {

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


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

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


_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.48855;
  void * D.48856;

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


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


