int main(int, char**) (int argc, char * * argv)
{
  bool retval.0;
  bool D.50026;
  int D.50029;
  int iftmp.1;
  bool D.50031;
  const short int D.48796;
  struct mem_functor1 D.48795;
  struct 
{
  void test::<T8b17> (struct test *, short int) * __pfn;
  long int __delta;
} D.50035;
  const struct string D.48799;
  struct allocator D.48798;
  const short int D.48801;
  struct mem_functor1 D.48800;
  struct 
{
  void test::<T8b17> (struct test *, short int) * __pfn;
  long int __delta;
} D.50036;
  const struct string D.48804;
  struct allocator D.48803;
  const int D.48848;
  struct const_mem_functor1 D.48847;
  struct 
{
  void test::<T8b1c> (const struct test *, int) * __pfn;
  long int __delta;
} D.50037;
  const struct string D.48851;
  struct allocator D.48850;
  const int D.48868;
  struct const_mem_functor1 D.48852;
  struct 
{
  void test::<T8b1c> (const struct test *, int) * __pfn;
  long int __delta;
} D.50038;
  const struct string D.48871;
  struct allocator D.48870;
  const int D.48875;
  struct const_mem_functor1 D.48874;
  struct 
{
  void test::<T8b1c> (const struct test *, int) * __pfn;
  long int __delta;
} D.50039;
  const struct string D.48878;
  struct allocator D.48877;
  const int D.48880;
  struct const_mem_functor1 D.48879;
  struct 
{
  void test::<T8b1c> (const struct test *, int) * __pfn;
  long int __delta;
} D.50040;
  const struct string D.48883;
  struct allocator D.48882;
  const float D.48927;
  struct volatile_mem_functor1 D.48926;
  struct 
{
  void test::<T8b21> (volatile struct test *, float) * __pfn;
  long int __delta;
} D.50041;
  const struct string D.48930;
  struct allocator D.48929;
  const float D.48932;
  struct volatile_mem_functor1 D.48931;
  struct 
{
  void test::<T8b21> (volatile struct test *, float) * __pfn;
  long int __delta;
} D.50042;
  const struct string D.48935;
  struct allocator D.48934;
  const double D.48979;
  struct const_volatile_mem_functor1 D.48978;
  struct 
{
  void test::<T8b26> (const volatile struct test *, double) * __pfn;
  long int __delta;
} D.50043;
  const struct string D.48982;
  struct allocator D.48981;
  const double D.48984;
  struct const_volatile_mem_functor1 D.48983;
  struct 
{
  void test::<T8b26> (const volatile struct test *, double) * __pfn;
  long int __delta;
} D.50044;
  const struct string D.48987;
  struct allocator D.48986;
  const double D.48991;
  struct const_volatile_mem_functor1 D.48990;
  struct 
{
  void test::<T8b26> (const volatile struct test *, double) * __pfn;
  long int __delta;
} D.50045;
  const struct string D.48994;
  struct allocator D.48993;
  const double D.48996;
  struct const_volatile_mem_functor1 D.48995;
  struct 
{
  void test::<T8b26> (const volatile struct test *, double) * __pfn;
  long int __delta;
} D.50046;
  const struct string D.48999;
  struct allocator D.48998;
  const short int D.49084;
  struct bound_mem_functor1 D.49083;
  struct 
{
  void test::<T8b17> (struct test *, short int) * __pfn;
  long int __delta;
} D.50047;
  const struct string D.49087;
  struct allocator D.49086;
  const short int D.49096;
  struct bound_mem_functor1 D.49095;
  struct 
{
  void test::<T8b17> (struct test *, short int) * __pfn;
  long int __delta;
} D.50048;
  const struct string D.49099;
  struct allocator D.49098;
  const int D.49156;
  struct bound_const_mem_functor1 D.49155;
  struct 
{
  void test::<T8b1c> (const struct test *, int) * __pfn;
  long int __delta;
} D.50049;
  const struct string D.49159;
  struct allocator D.49158;
  const int D.49168;
  struct bound_const_mem_functor1 D.49167;
  struct 
{
  void test::<T8b1c> (const struct test *, int) * __pfn;
  long int __delta;
} D.50050;
  const struct string D.49171;
  struct allocator D.49170;
  const float D.49228;
  struct bound_volatile_mem_functor1 D.49227;
  struct 
{
  void test::<T8b21> (volatile struct test *, float) * __pfn;
  long int __delta;
} D.50051;
  const struct string D.49231;
  struct allocator D.49230;
  const float D.49240;
  struct bound_volatile_mem_functor1 D.49239;
  struct 
{
  void test::<T8b21> (volatile struct test *, float) * __pfn;
  long int __delta;
} D.50052;
  const struct string D.49243;
  struct allocator D.49242;
  int iftmp.2;
  bool D.50054;

  {
    struct TestUtilities * util;

    util = TestUtilities::get_instance ();
    D.50026 = TestUtilities::check_command_args (util, argc, argv);
    retval.0 = ~D.50026;
    if (retval.0 != 0) goto <D.50027>; else goto <D.50028>;
    <D.50027>:
    D.50031 = TestUtilities::get_result_and_delete_instance ();
    if (D.50031 != 0) goto <D.50032>; else goto <D.50033>;
    <D.50032>:
    iftmp.1 = 0;
    goto <D.50034>;
    <D.50033>:
    iftmp.1 = 1;
    <D.50034>:
    D.50029 = iftmp.1;
    return D.50029;
    <D.50028>:
    {
      struct test t;

      try
        {
          D.48796 = 1;
          try
            {
              D.50035.__pfn = foo;
              D.50035.__delta = 0;
              D.48795 = sigc::mem_fun<short int, void, {anonymous}::test> (D.50035);
              try
                {
                  sigc::mem_functor1<void, {anonymous}::test, short int>::operator() (&D.48795, &t, &D.48796);
                }
              finally
                {
                  D.48795 = {CLOBBER};
                }
            }
          finally
            {
              D.48796 = {CLOBBER};
            }
          std::allocator<char>::allocator (&D.48798);
          try
            {
              std::basic_string<char>::basic_string (&D.48799, "test::foo(short 1)", &D.48798);
              try
                {
                  TestUtilities::check_result (util, &result_stream, &D.48799);
                }
              finally
                {
                  std::basic_string<char>::~basic_string (&D.48799);
                  D.48799 = {CLOBBER};
                }
            }
          finally
            {
              std::allocator<char>::~allocator (&D.48798);
              D.48798 = {CLOBBER};
            }
          D.48801 = 1;
          try
            {
              D.50036.__pfn = foo;
              D.50036.__delta = 0;
              D.48800 = sigc::mem_fun<short int, void, {anonymous}::test> (D.50036);
              try
                {
                  sigc::mem_functor1<void, {anonymous}::test, short int>::operator() (&D.48800, &t, &D.48801);
                }
              finally
                {
                  D.48800 = {CLOBBER};
                }
            }
          finally
            {
              D.48801 = {CLOBBER};
            }
          std::allocator<char>::allocator (&D.48803);
          try
            {
              std::basic_string<char>::basic_string (&D.48804, "test::foo(short 1)", &D.48803);
              try
                {
                  TestUtilities::check_result (util, &result_stream, &D.48804);
                }
              finally
                {
                  std::basic_string<char>::~basic_string (&D.48804);
                  D.48804 = {CLOBBER};
                }
            }
          finally
            {
              std::allocator<char>::~allocator (&D.48803);
              D.48803 = {CLOBBER};
            }
        }
      finally
        {
          t = {CLOBBER};
        }
    }
    {
      struct test t;

      try
        {
          D.48848 = 2;
          try
            {
              D.50037.__pfn = foo_const;
              D.50037.__delta = 0;
              D.48847 = sigc::mem_fun<int, void, {anonymous}::test> (D.50037);
              try
                {
                  sigc::const_mem_functor1<void, {anonymous}::test, int>::operator() (&D.48847, &t, &D.48848);
                }
              finally
                {
                  D.48847 = {CLOBBER};
                }
            }
          finally
            {
              D.48848 = {CLOBBER};
            }
          std::allocator<char>::allocator (&D.48850);
          try
            {
              std::basic_string<char>::basic_string (&D.48851, "test::foo_const(int 2)", &D.48850);
              try
                {
                  TestUtilities::check_result (util, &result_stream, &D.48851);
                }
              finally
                {
                  std::basic_string<char>::~basic_string (&D.48851);
                  D.48851 = {CLOBBER};
                }
            }
          finally
            {
              std::allocator<char>::~allocator (&D.48850);
              D.48850 = {CLOBBER};
            }
          D.48868 = 2;
          try
            {
              D.50038.__pfn = foo_const;
              D.50038.__delta = 0;
              D.48852 = sigc::mem_fun<int, void, {anonymous}::test> (D.50038);
              try
                {
                  sigc::const_mem_functor1<void, {anonymous}::test, int>::operator() (&D.48852, &t, &D.48868);
                }
              finally
                {
                  D.48852 = {CLOBBER};
                }
            }
          finally
            {
              D.48868 = {CLOBBER};
            }
          std::allocator<char>::allocator (&D.48870);
          try
            {
              std::basic_string<char>::basic_string (&D.48871, "test::foo_const(int 2)", &D.48870);
              try
                {
                  TestUtilities::check_result (util, &result_stream, &D.48871);
                }
              finally
                {
                  std::basic_string<char>::~basic_string (&D.48871);
                  D.48871 = {CLOBBER};
                }
            }
          finally
            {
              std::allocator<char>::~allocator (&D.48870);
              D.48870 = {CLOBBER};
            }
        }
      finally
        {
          t = {CLOBBER};
        }
    }
    {
      const struct test t;

      try
        {
          D.48875 = 3;
          try
            {
              D.50039.__pfn = foo_const;
              D.50039.__delta = 0;
              D.48874 = sigc::mem_fun<int, void, {anonymous}::test> (D.50039);
              try
                {
                  sigc::const_mem_functor1<void, {anonymous}::test, int>::operator() (&D.48874, &t, &D.48875);
                }
              finally
                {
                  D.48874 = {CLOBBER};
                }
            }
          finally
            {
              D.48875 = {CLOBBER};
            }
          std::allocator<char>::allocator (&D.48877);
          try
            {
              std::basic_string<char>::basic_string (&D.48878, "test::foo_const(int 3)", &D.48877);
              try
                {
                  TestUtilities::check_result (util, &result_stream, &D.48878);
                }
              finally
                {
                  std::basic_string<char>::~basic_string (&D.48878);
                  D.48878 = {CLOBBER};
                }
            }
          finally
            {
              std::allocator<char>::~allocator (&D.48877);
              D.48877 = {CLOBBER};
            }
          D.48880 = 3;
          try
            {
              D.50040.__pfn = foo_const;
              D.50040.__delta = 0;
              D.48879 = sigc::mem_fun<int, void, {anonymous}::test> (D.50040);
              try
                {
                  sigc::const_mem_functor1<void, {anonymous}::test, int>::operator() (&D.48879, &t, &D.48880);
                }
              finally
                {
                  D.48879 = {CLOBBER};
                }
            }
          finally
            {
              D.48880 = {CLOBBER};
            }
          std::allocator<char>::allocator (&D.48882);
          try
            {
              std::basic_string<char>::basic_string (&D.48883, "test::foo_const(int 3)", &D.48882);
              try
                {
                  TestUtilities::check_result (util, &result_stream, &D.48883);
                }
              finally
                {
                  std::basic_string<char>::~basic_string (&D.48883);
                  D.48883 = {CLOBBER};
                }
            }
          finally
            {
              std::allocator<char>::~allocator (&D.48882);
              D.48882 = {CLOBBER};
            }
        }
      finally
        {
          t = {CLOBBER};
        }
    }
    {
      struct test t;

      try
        {
          D.48927 = 4.0e+0;
          try
            {
              D.50041.__pfn = foo_volatile;
              D.50041.__delta = 0;
              D.48926 = sigc::mem_fun<float, void, {anonymous}::test> (D.50041);
              try
                {
                  sigc::volatile_mem_functor1<void, {anonymous}::test, float>::operator() (&D.48926, &t, &D.48927);
                }
              finally
                {
                  D.48926 = {CLOBBER};
                }
            }
          finally
            {
              D.48927 = {CLOBBER};
            }
          std::allocator<char>::allocator (&D.48929);
          try
            {
              std::basic_string<char>::basic_string (&D.48930, "test::foo_volatile(float 4)", &D.48929);
              try
                {
                  TestUtilities::check_result (util, &result_stream, &D.48930);
                }
              finally
                {
                  std::basic_string<char>::~basic_string (&D.48930);
                  D.48930 = {CLOBBER};
                }
            }
          finally
            {
              std::allocator<char>::~allocator (&D.48929);
              D.48929 = {CLOBBER};
            }
          D.48932 = 4.0e+0;
          try
            {
              D.50042.__pfn = foo_volatile;
              D.50042.__delta = 0;
              D.48931 = sigc::mem_fun<float, void, {anonymous}::test> (D.50042);
              try
                {
                  sigc::volatile_mem_functor1<void, {anonymous}::test, float>::operator() (&D.48931, &t, &D.48932);
                }
              finally
                {
                  D.48931 = {CLOBBER};
                }
            }
          finally
            {
              D.48932 = {CLOBBER};
            }
          std::allocator<char>::allocator (&D.48934);
          try
            {
              std::basic_string<char>::basic_string (&D.48935, "test::foo_volatile(float 4)", &D.48934);
              try
                {
                  TestUtilities::check_result (util, &result_stream, &D.48935);
                }
              finally
                {
                  std::basic_string<char>::~basic_string (&D.48935);
                  D.48935 = {CLOBBER};
                }
            }
          finally
            {
              std::allocator<char>::~allocator (&D.48934);
              D.48934 = {CLOBBER};
            }
        }
      finally
        {
          t = {CLOBBER};
        }
    }
    {
      struct test t;

      try
        {
          D.48979 = 5.0e+0;
          try
            {
              D.50043.__pfn = foo_const_volatile;
              D.50043.__delta = 0;
              D.48978 = sigc::mem_fun<double, void, {anonymous}::test> (D.50043);
              try
                {
                  sigc::const_volatile_mem_functor1<void, {anonymous}::test, double>::operator() (&D.48978, &t, &D.48979);
                }
              finally
                {
                  D.48978 = {CLOBBER};
                }
            }
          finally
            {
              D.48979 = {CLOBBER};
            }
          std::allocator<char>::allocator (&D.48981);
          try
            {
              std::basic_string<char>::basic_string (&D.48982, "test::foo_const_volatile(double 5)", &D.48981);
              try
                {
                  TestUtilities::check_result (util, &result_stream, &D.48982);
                }
              finally
                {
                  std::basic_string<char>::~basic_string (&D.48982);
                  D.48982 = {CLOBBER};
                }
            }
          finally
            {
              std::allocator<char>::~allocator (&D.48981);
              D.48981 = {CLOBBER};
            }
          D.48984 = 5.0e+0;
          try
            {
              D.50044.__pfn = foo_const_volatile;
              D.50044.__delta = 0;
              D.48983 = sigc::mem_fun<double, void, {anonymous}::test> (D.50044);
              try
                {
                  sigc::const_volatile_mem_functor1<void, {anonymous}::test, double>::operator() (&D.48983, &t, &D.48984);
                }
              finally
                {
                  D.48983 = {CLOBBER};
                }
            }
          finally
            {
              D.48984 = {CLOBBER};
            }
          std::allocator<char>::allocator (&D.48986);
          try
            {
              std::basic_string<char>::basic_string (&D.48987, "test::foo_const_volatile(double 5)", &D.48986);
              try
                {
                  TestUtilities::check_result (util, &result_stream, &D.48987);
                }
              finally
                {
                  std::basic_string<char>::~basic_string (&D.48987);
                  D.48987 = {CLOBBER};
                }
            }
          finally
            {
              std::allocator<char>::~allocator (&D.48986);
              D.48986 = {CLOBBER};
            }
        }
      finally
        {
          t = {CLOBBER};
        }
    }
    {
      const struct test t;

      try
        {
          D.48991 = 6.0e+0;
          try
            {
              D.50045.__pfn = foo_const_volatile;
              D.50045.__delta = 0;
              D.48990 = sigc::mem_fun<double, void, {anonymous}::test> (D.50045);
              try
                {
                  sigc::const_volatile_mem_functor1<void, {anonymous}::test, double>::operator() (&D.48990, &t, &D.48991);
                }
              finally
                {
                  D.48990 = {CLOBBER};
                }
            }
          finally
            {
              D.48991 = {CLOBBER};
            }
          std::allocator<char>::allocator (&D.48993);
          try
            {
              std::basic_string<char>::basic_string (&D.48994, "test::foo_const_volatile(double 6)", &D.48993);
              try
                {
                  TestUtilities::check_result (util, &result_stream, &D.48994);
                }
              finally
                {
                  std::basic_string<char>::~basic_string (&D.48994);
                  D.48994 = {CLOBBER};
                }
            }
          finally
            {
              std::allocator<char>::~allocator (&D.48993);
              D.48993 = {CLOBBER};
            }
          D.48996 = 6.0e+0;
          try
            {
              D.50046.__pfn = foo_const_volatile;
              D.50046.__delta = 0;
              D.48995 = sigc::mem_fun<double, void, {anonymous}::test> (D.50046);
              try
                {
                  sigc::const_volatile_mem_functor1<void, {anonymous}::test, double>::operator() (&D.48995, &t, &D.48996);
                }
              finally
                {
                  D.48995 = {CLOBBER};
                }
            }
          finally
            {
              D.48996 = {CLOBBER};
            }
          std::allocator<char>::allocator (&D.48998);
          try
            {
              std::basic_string<char>::basic_string (&D.48999, "test::foo_const_volatile(double 6)", &D.48998);
              try
                {
                  TestUtilities::check_result (util, &result_stream, &D.48999);
                }
              finally
                {
                  std::basic_string<char>::~basic_string (&D.48999);
                  D.48999 = {CLOBBER};
                }
            }
          finally
            {
              std::allocator<char>::~allocator (&D.48998);
              D.48998 = {CLOBBER};
            }
        }
      finally
        {
          t = {CLOBBER};
        }
    }
    {
      struct test t;

      try
        {
          D.49084 = 9;
          try
            {
              D.50047.__pfn = foo;
              D.50047.__delta = 0;
              D.49083 = sigc::mem_fun<short int, void, {anonymous}::test, {anonymous}::test> (&t, D.50047); [return slot optimization]
              try
                {
                  sigc::bound_mem_functor1<void, {anonymous}::test, short int>::operator() (&D.49083, &D.49084);
                }
              finally
                {
                  D.49083 = {CLOBBER};
                }
            }
          finally
            {
              D.49084 = {CLOBBER};
            }
          std::allocator<char>::allocator (&D.49086);
          try
            {
              std::basic_string<char>::basic_string (&D.49087, "test::foo(short 9)", &D.49086);
              try
                {
                  TestUtilities::check_result (util, &result_stream, &D.49087);
                }
              finally
                {
                  std::basic_string<char>::~basic_string (&D.49087);
                  D.49087 = {CLOBBER};
                }
            }
          finally
            {
              std::allocator<char>::~allocator (&D.49086);
              D.49086 = {CLOBBER};
            }
          D.49096 = 9;
          try
            {
              D.50048.__pfn = foo;
              D.50048.__delta = 0;
              D.49095 = sigc::mem_fun<short int, void, {anonymous}::test, {anonymous}::test> (&t, D.50048); [return slot optimization]
              try
                {
                  sigc::bound_mem_functor1<void, {anonymous}::test, short int>::operator() (&D.49095, &D.49096);
                }
              finally
                {
                  D.49095 = {CLOBBER};
                }
            }
          finally
            {
              D.49096 = {CLOBBER};
            }
          std::allocator<char>::allocator (&D.49098);
          try
            {
              std::basic_string<char>::basic_string (&D.49099, "test::foo(short 9)", &D.49098);
              try
                {
                  TestUtilities::check_result (util, &result_stream, &D.49099);
                }
              finally
                {
                  std::basic_string<char>::~basic_string (&D.49099);
                  D.49099 = {CLOBBER};
                }
            }
          finally
            {
              std::allocator<char>::~allocator (&D.49098);
              D.49098 = {CLOBBER};
            }
          D.49156 = 9;
          try
            {
              D.50049.__pfn = foo_const;
              D.50049.__delta = 0;
              D.49155 = sigc::mem_fun<int, void, {anonymous}::test, {anonymous}::test> (&t, D.50049); [return slot optimization]
              try
                {
                  sigc::bound_const_mem_functor1<void, {anonymous}::test, int>::operator() (&D.49155, &D.49156);
                }
              finally
                {
                  D.49155 = {CLOBBER};
                }
            }
          finally
            {
              D.49156 = {CLOBBER};
            }
          std::allocator<char>::allocator (&D.49158);
          try
            {
              std::basic_string<char>::basic_string (&D.49159, "test::foo_const(int 9)", &D.49158);
              try
                {
                  TestUtilities::check_result (util, &result_stream, &D.49159);
                }
              finally
                {
                  std::basic_string<char>::~basic_string (&D.49159);
                  D.49159 = {CLOBBER};
                }
            }
          finally
            {
              std::allocator<char>::~allocator (&D.49158);
              D.49158 = {CLOBBER};
            }
          D.49168 = 9;
          try
            {
              D.50050.__pfn = foo_const;
              D.50050.__delta = 0;
              D.49167 = sigc::mem_fun<int, void, {anonymous}::test, {anonymous}::test> (&t, D.50050); [return slot optimization]
              try
                {
                  sigc::bound_const_mem_functor1<void, {anonymous}::test, int>::operator() (&D.49167, &D.49168);
                }
              finally
                {
                  D.49167 = {CLOBBER};
                }
            }
          finally
            {
              D.49168 = {CLOBBER};
            }
          std::allocator<char>::allocator (&D.49170);
          try
            {
              std::basic_string<char>::basic_string (&D.49171, "test::foo_const(int 9)", &D.49170);
              try
                {
                  TestUtilities::check_result (util, &result_stream, &D.49171);
                }
              finally
                {
                  std::basic_string<char>::~basic_string (&D.49171);
                  D.49171 = {CLOBBER};
                }
            }
          finally
            {
              std::allocator<char>::~allocator (&D.49170);
              D.49170 = {CLOBBER};
            }
          D.49228 = 9.0e+0;
          try
            {
              D.50051.__pfn = foo_volatile;
              D.50051.__delta = 0;
              D.49227 = sigc::mem_fun<float, void, {anonymous}::test, {anonymous}::test> (&t, D.50051); [return slot optimization]
              try
                {
                  sigc::bound_volatile_mem_functor1<void, {anonymous}::test, float>::operator() (&D.49227, &D.49228);
                }
              finally
                {
                  D.49227 = {CLOBBER};
                }
            }
          finally
            {
              D.49228 = {CLOBBER};
            }
          std::allocator<char>::allocator (&D.49230);
          try
            {
              std::basic_string<char>::basic_string (&D.49231, "test::foo_volatile(float 9)", &D.49230);
              try
                {
                  TestUtilities::check_result (util, &result_stream, &D.49231);
                }
              finally
                {
                  std::basic_string<char>::~basic_string (&D.49231);
                  D.49231 = {CLOBBER};
                }
            }
          finally
            {
              std::allocator<char>::~allocator (&D.49230);
              D.49230 = {CLOBBER};
            }
          D.49240 = 9.0e+0;
          try
            {
              D.50052.__pfn = foo_volatile;
              D.50052.__delta = 0;
              D.49239 = sigc::mem_fun<float, void, {anonymous}::test, {anonymous}::test> (&t, D.50052); [return slot optimization]
              try
                {
                  sigc::bound_volatile_mem_functor1<void, {anonymous}::test, float>::operator() (&D.49239, &D.49240);
                }
              finally
                {
                  D.49239 = {CLOBBER};
                }
            }
          finally
            {
              D.49240 = {CLOBBER};
            }
          std::allocator<char>::allocator (&D.49242);
          try
            {
              std::basic_string<char>::basic_string (&D.49243, "test::foo_volatile(float 9)", &D.49242);
              try
                {
                  TestUtilities::check_result (util, &result_stream, &D.49243);
                }
              finally
                {
                  std::basic_string<char>::~basic_string (&D.49243);
                  D.49243 = {CLOBBER};
                }
            }
          finally
            {
              std::allocator<char>::~allocator (&D.49242);
              D.49242 = {CLOBBER};
            }
        }
      finally
        {
          t = {CLOBBER};
        }
    }
    D.50054 = TestUtilities::get_result_and_delete_instance ();
    if (D.50054 != 0) goto <D.50055>; else goto <D.50056>;
    <D.50055>:
    iftmp.2 = 0;
    goto <D.50057>;
    <D.50056>:
    iftmp.2 = 1;
    <D.50057>:
    D.50029 = iftmp.2;
    return D.50029;
  }
  D.50029 = 0;
  return D.50029;
}


void {anonymous}::test::foo_const_volatile(double) const volatile (const volatile struct test * const this, double i1)
{
  struct basic_ostream & D.50143;
  struct __ostream_type & D.50144;

  D.50143 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "test::foo_const_volatile(double ");
  D.50144 = std::basic_ostream<char>::operator<< (D.50143, i1);
  std::operator<< <std::char_traits<char> > (D.50144, 41);
}


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.50149;
  int (*__vtbl_ptr_type) () * D.50150;
  long int D.50151;
  sizetype D.50152;
  struct basic_ios * D.50153;
  long unsigned int D.50155;
  long int D.50156;
  struct basic_ostream & D.50157;

  if (__s == 0B) goto <D.50147>; else goto <D.50148>;
  <D.50147>:
  D.50149 = __out->_vptr.basic_ostream;
  D.50150 = D.50149 + 18446744073709551592;
  D.50151 = MEM[(long int *)D.50150];
  D.50152 = (sizetype) D.50151;
  D.50153 = __out + D.50152;
  std::basic_ios<char>::setstate (D.50153, 1);
  goto <D.50154>;
  <D.50148>:
  D.50155 = std::char_traits<char>::length (__s);
  D.50156 = (long int) D.50155;
  std::__ostream_insert<char, std::char_traits<char> > (__out, __s, D.50156);
  <D.50154>:
  D.50157 = __out;
  return D.50157;
}


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.50159;
  _Ios_Iostate D.50160;

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


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

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


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

  __a.3 = (int) __a;
  __b.4 = (int) __b;
  D.50167 = __a.3 | __b.4;
  D.50164 = (_Ios_Iostate) D.50167;
  return D.50164;
}


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

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


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

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


std::basic_ostream<char, _Traits>& std::operator<<(std::basic_ostream<char, _Traits>&, char) [with _Traits = std::char_traits<char>] (struct basic_ostream & __out, char __c)
{
  struct basic_ostream & D.50176;

  D.50176 = std::__ostream_insert<char, std::char_traits<char> > (__out, &__c, 1);
  return D.50176;
}


void {anonymous}::test::foo_volatile(float) volatile (volatile struct test * const this, float i1)
{
  struct basic_ostream & D.50179;
  struct __ostream_type & D.50180;

  D.50179 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "test::foo_volatile(float ");
  D.50180 = std::basic_ostream<char>::operator<< (D.50179, i1);
  std::operator<< <std::char_traits<char> > (D.50180, 41);
}


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

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


void {anonymous}::test::foo_const(int) const (const struct test * const this, int i1)
{
  struct basic_ostream & D.50187;
  struct basic_ostream & D.50188;

  D.50187 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "test::foo_const(int ");
  D.50188 = std::basic_ostream<char>::operator<< (D.50187, i1);
  std::operator<< <std::char_traits<char> > (D.50188, 41);
}


void {anonymous}::test::foo(short int) (struct test * const this, short int i1)
{
  int D.50191;
  struct basic_ostream & D.50192;
  struct basic_ostream & D.50193;

  D.50191 = (int) i1;
  D.50192 = std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "test::foo(short ");
  D.50193 = std::basic_ostream<char>::operator<< (D.50192, D.50191);
  std::operator<< <std::char_traits<char> > (D.50193, 41);
}


T_return sigc::mem_functor1<T_arg1, T_return, T_obj>::operator()(T_obj&, typename sigc::type_trait<T_arg3>::take) const [with T_return = void; T_obj = {anonymous}::test; T_arg1 = short int; typename sigc::type_trait<T_arg3>::take = const short int&] (const struct mem_functor1 * const this, struct test & _A_obj, const short int & _A_a1)
{
  void test::<T8b17> (struct test *, short int) * iftmp.5;
  void test::<T8b17> (struct test *, short int) * D.50197;
  long int D.50198;
  long int D.50199;
  long int D.50203;
  sizetype D.50204;
  struct test * D.50205;
  int (*__vtbl_ptr_type) () * D.50206;
  long int D.50207;
  sizetype D.50208;
  int (*__vtbl_ptr_type) () * D.50209;
  short int D.50210;
  int D.50211;

  D.50197 = this->func_ptr_.__pfn;
  D.50198 = (long int) D.50197;
  D.50199 = D.50198 & 1;
  if (D.50199 == 0) goto <D.50200>; else goto <D.50201>;
  <D.50200>:
  iftmp.5 = this->func_ptr_.__pfn;
  goto <D.50202>;
  <D.50201>:
  D.50203 = this->func_ptr_.__delta;
  D.50204 = (sizetype) D.50203;
  D.50205 = _A_obj + D.50204;
  D.50206 = MEM[(int (*__vtbl_ptr_type) () * *)D.50205];
  D.50197 = this->func_ptr_.__pfn;
  D.50198 = (long int) D.50197;
  D.50207 = D.50198 + -1;
  D.50208 = (sizetype) D.50207;
  D.50209 = D.50206 + D.50208;
  iftmp.5 = *D.50209;
  <D.50202>:
  D.50210 = *_A_a1;
  D.50211 = (int) D.50210;
  D.50203 = this->func_ptr_.__delta;
  D.50204 = (sizetype) D.50203;
  D.50205 = _A_obj + D.50204;
  iftmp.5 (D.50205, D.50211);
  return;
}


sigc::mem_functor1<T_return, T_obj, T_arg1> sigc::mem_fun(T_return (T_obj::*)(T_arg1)) [with T_arg1 = short int; T_return = void; T_obj = {anonymous}::test] (struct 
{
  void test::<T8b17> (struct test *, short int) * __pfn;
  long int __delta;
} _A_func)
{
  struct mem_functor1 D.50213;
  struct mem_functor1 D.49428;

  sigc::mem_functor1<void, {anonymous}::test, short int>::mem_functor1 (&D.49428, _A_func);
  try
    {
      D.50213 = D.49428;
      return D.50213;
    }
  finally
    {
      D.49428 = {CLOBBER};
    }
}


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


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

}


T_return sigc::mem_functor1<T_arg1, T_return, T_obj>::operator()(T_obj*, typename sigc::type_trait<T_arg3>::take) const [with T_return = void; T_obj = {anonymous}::test; T_arg1 = short int; typename sigc::type_trait<T_arg3>::take = const short int&] (const struct mem_functor1 * const this, struct test * _A_obj, const short int & _A_a1)
{
  void test::<T8b17> (struct test *, short int) * iftmp.6;
  void test::<T8b17> (struct test *, short int) * D.50217;
  long int D.50218;
  long int D.50219;
  long int D.50223;
  sizetype D.50224;
  struct test * D.50225;
  int (*__vtbl_ptr_type) () * D.50226;
  long int D.50227;
  sizetype D.50228;
  int (*__vtbl_ptr_type) () * D.50229;
  short int D.50230;
  int D.50231;

  D.50217 = this->func_ptr_.__pfn;
  D.50218 = (long int) D.50217;
  D.50219 = D.50218 & 1;
  if (D.50219 == 0) goto <D.50220>; else goto <D.50221>;
  <D.50220>:
  iftmp.6 = this->func_ptr_.__pfn;
  goto <D.50222>;
  <D.50221>:
  D.50223 = this->func_ptr_.__delta;
  D.50224 = (sizetype) D.50223;
  D.50225 = _A_obj + D.50224;
  D.50226 = MEM[(int (*__vtbl_ptr_type) () * *)D.50225];
  D.50217 = this->func_ptr_.__pfn;
  D.50218 = (long int) D.50217;
  D.50227 = D.50218 + -1;
  D.50228 = (sizetype) D.50227;
  D.50229 = D.50226 + D.50228;
  iftmp.6 = *D.50229;
  <D.50222>:
  D.50230 = *_A_a1;
  D.50231 = (int) D.50230;
  D.50223 = this->func_ptr_.__delta;
  D.50224 = (sizetype) D.50223;
  D.50225 = _A_obj + D.50224;
  iftmp.6 (D.50225, D.50231);
  return;
}


T_return sigc::const_mem_functor1<T_arg1, T_return, T_obj>::operator()(const T_obj&, typename sigc::type_trait<T_arg3>::take) const [with T_return = void; T_obj = {anonymous}::test; T_arg1 = int; typename sigc::type_trait<T_arg3>::take = const int&] (const struct const_mem_functor1 * const this, const struct test & _A_obj, const int & _A_a1)
{
  void test::<T8b1c> (const struct test *, int) * iftmp.7;
  void test::<T8b1c> (const struct test *, int) * D.50234;
  long int D.50235;
  long int D.50236;
  long int D.50240;
  sizetype D.50241;
  const struct test * D.50242;
  int (*__vtbl_ptr_type) () * D.50243;
  long int D.50244;
  sizetype D.50245;
  int (*__vtbl_ptr_type) () * D.50246;
  int D.50247;

  D.50234 = this->func_ptr_.__pfn;
  D.50235 = (long int) D.50234;
  D.50236 = D.50235 & 1;
  if (D.50236 == 0) goto <D.50237>; else goto <D.50238>;
  <D.50237>:
  iftmp.7 = this->func_ptr_.__pfn;
  goto <D.50239>;
  <D.50238>:
  D.50240 = this->func_ptr_.__delta;
  D.50241 = (sizetype) D.50240;
  D.50242 = _A_obj + D.50241;
  D.50243 = MEM[(int (*__vtbl_ptr_type) () * *)D.50242];
  D.50234 = this->func_ptr_.__pfn;
  D.50235 = (long int) D.50234;
  D.50244 = D.50235 + -1;
  D.50245 = (sizetype) D.50244;
  D.50246 = D.50243 + D.50245;
  iftmp.7 = *D.50246;
  <D.50239>:
  D.50247 = *_A_a1;
  D.50240 = this->func_ptr_.__delta;
  D.50241 = (sizetype) D.50240;
  D.50242 = _A_obj + D.50241;
  iftmp.7 (D.50242, D.50247);
  return;
}


sigc::const_mem_functor1<T_return, T_obj, T_arg1> sigc::mem_fun(T_return (T_obj::*)(T_arg1) const) [with T_arg1 = int; T_return = void; T_obj = {anonymous}::test] (struct 
{
  void test::<T8b1c> (const struct test *, int) * __pfn;
  long int __delta;
} _A_func)
{
  struct const_mem_functor1 D.50249;
  struct const_mem_functor1 D.49479;

  sigc::const_mem_functor1<void, {anonymous}::test, int>::const_mem_functor1 (&D.49479, _A_func);
  try
    {
      D.50249 = D.49479;
      return D.50249;
    }
  finally
    {
      D.49479 = {CLOBBER};
    }
}


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


T_return sigc::const_mem_functor1<T_arg1, T_return, T_obj>::operator()(const T_obj*, typename sigc::type_trait<T_arg3>::take) const [with T_return = void; T_obj = {anonymous}::test; T_arg1 = int; typename sigc::type_trait<T_arg3>::take = const int&] (const struct const_mem_functor1 * const this, const struct test * _A_obj, const int & _A_a1)
{
  void test::<T8b1c> (const struct test *, int) * iftmp.8;
  void test::<T8b1c> (const struct test *, int) * D.50253;
  long int D.50254;
  long int D.50255;
  long int D.50259;
  sizetype D.50260;
  const struct test * D.50261;
  int (*__vtbl_ptr_type) () * D.50262;
  long int D.50263;
  sizetype D.50264;
  int (*__vtbl_ptr_type) () * D.50265;
  int D.50266;

  D.50253 = this->func_ptr_.__pfn;
  D.50254 = (long int) D.50253;
  D.50255 = D.50254 & 1;
  if (D.50255 == 0) goto <D.50256>; else goto <D.50257>;
  <D.50256>:
  iftmp.8 = this->func_ptr_.__pfn;
  goto <D.50258>;
  <D.50257>:
  D.50259 = this->func_ptr_.__delta;
  D.50260 = (sizetype) D.50259;
  D.50261 = _A_obj + D.50260;
  D.50262 = MEM[(int (*__vtbl_ptr_type) () * *)D.50261];
  D.50253 = this->func_ptr_.__pfn;
  D.50254 = (long int) D.50253;
  D.50263 = D.50254 + -1;
  D.50264 = (sizetype) D.50263;
  D.50265 = D.50262 + D.50264;
  iftmp.8 = *D.50265;
  <D.50258>:
  D.50266 = *_A_a1;
  D.50259 = this->func_ptr_.__delta;
  D.50260 = (sizetype) D.50259;
  D.50261 = _A_obj + D.50260;
  iftmp.8 (D.50261, D.50266);
  return;
}


T_return sigc::volatile_mem_functor1<T_return, T_obj, T_arg1>::operator()(T_obj&, typename sigc::type_trait<T_arg3>::take) const [with T_return = void; T_obj = {anonymous}::test; T_arg1 = float; typename sigc::type_trait<T_arg3>::take = const float&] (const struct volatile_mem_functor1 * const this, struct test & _A_obj, const float & _A_a1)
{
  void test::<T8b21> (volatile struct test *, float) * iftmp.9;
  void test::<T8b21> (volatile struct test *, float) * D.50269;
  long int D.50270;
  long int D.50271;
  long int D.50275;
  sizetype D.50276;
  struct test * D.50277;
  int (*__vtbl_ptr_type) () * D.50278;
  long int D.50279;
  sizetype D.50280;
  int (*__vtbl_ptr_type) () * D.50281;
  float D.50282;
  volatile struct test * D.50283;

  D.50269 = this->func_ptr_.__pfn;
  D.50270 = (long int) D.50269;
  D.50271 = D.50270 & 1;
  if (D.50271 == 0) goto <D.50272>; else goto <D.50273>;
  <D.50272>:
  iftmp.9 = this->func_ptr_.__pfn;
  goto <D.50274>;
  <D.50273>:
  D.50275 = this->func_ptr_.__delta;
  D.50276 = (sizetype) D.50275;
  D.50277 = _A_obj + D.50276;
  D.50278 = MEM[(int (*__vtbl_ptr_type) () * *)D.50277];
  D.50269 = this->func_ptr_.__pfn;
  D.50270 = (long int) D.50269;
  D.50279 = D.50270 + -1;
  D.50280 = (sizetype) D.50279;
  D.50281 = D.50278 + D.50280;
  iftmp.9 = *D.50281;
  <D.50274>:
  D.50282 = *_A_a1;
  D.50275 = this->func_ptr_.__delta;
  D.50276 = (sizetype) D.50275;
  D.50283 = _A_obj + D.50276;
  iftmp.9 (D.50283, D.50282);
  return;
}


sigc::volatile_mem_functor1<T_return, T_obj, T_arg1> sigc::mem_fun(T_return (T_obj::*)(T_arg1) volatile) [with T_arg1 = float; T_return = void; T_obj = {anonymous}::test] (struct 
{
  void test::<T8b21> (volatile struct test *, float) * __pfn;
  long int __delta;
} _A_func)
{
  struct volatile_mem_functor1 D.50285;
  struct volatile_mem_functor1 D.49495;

  sigc::volatile_mem_functor1<void, {anonymous}::test, float>::volatile_mem_functor1 (&D.49495, _A_func);
  try
    {
      D.50285 = D.49495;
      return D.50285;
    }
  finally
    {
      D.49495 = {CLOBBER};
    }
}


sigc::volatile_mem_functor1<T_return, T_obj, T_arg1>::volatile_mem_functor1(sigc::volatile_mem_functor1<T_return, T_obj, T_arg1>::function_type) [with T_return = void; T_obj = {anonymous}::test; T_arg1 = float; sigc::volatile_mem_functor1<T_return, T_obj, T_arg1>::function_type = void ({anonymous}::test::*)(float) volatile] (struct volatile_mem_functor1 * const this, struct function_type _A_func)
{
  sigc::functor_base::functor_base (this);
  this->func_ptr_ = _A_func;
}


T_return sigc::volatile_mem_functor1<T_return, T_obj, T_arg1>::operator()(T_obj*, typename sigc::type_trait<T_arg3>::take) const [with T_return = void; T_obj = {anonymous}::test; T_arg1 = float; typename sigc::type_trait<T_arg3>::take = const float&] (const struct volatile_mem_functor1 * const this, struct test * _A_obj, const float & _A_a1)
{
  void test::<T8b21> (volatile struct test *, float) * iftmp.10;
  void test::<T8b21> (volatile struct test *, float) * D.50289;
  long int D.50290;
  long int D.50291;
  long int D.50295;
  sizetype D.50296;
  struct test * D.50297;
  int (*__vtbl_ptr_type) () * D.50298;
  long int D.50299;
  sizetype D.50300;
  int (*__vtbl_ptr_type) () * D.50301;
  float D.50302;
  volatile struct test * D.50303;

  D.50289 = this->func_ptr_.__pfn;
  D.50290 = (long int) D.50289;
  D.50291 = D.50290 & 1;
  if (D.50291 == 0) goto <D.50292>; else goto <D.50293>;
  <D.50292>:
  iftmp.10 = this->func_ptr_.__pfn;
  goto <D.50294>;
  <D.50293>:
  D.50295 = this->func_ptr_.__delta;
  D.50296 = (sizetype) D.50295;
  D.50297 = _A_obj + D.50296;
  D.50298 = MEM[(int (*__vtbl_ptr_type) () * *)D.50297];
  D.50289 = this->func_ptr_.__pfn;
  D.50290 = (long int) D.50289;
  D.50299 = D.50290 + -1;
  D.50300 = (sizetype) D.50299;
  D.50301 = D.50298 + D.50300;
  iftmp.10 = *D.50301;
  <D.50294>:
  D.50302 = *_A_a1;
  D.50295 = this->func_ptr_.__delta;
  D.50296 = (sizetype) D.50295;
  D.50303 = _A_obj + D.50296;
  iftmp.10 (D.50303, D.50302);
  return;
}


T_return sigc::const_volatile_mem_functor1<T_return, T_obj, T_arg1>::operator()(const T_obj&, typename sigc::type_trait<T_arg3>::take) const [with T_return = void; T_obj = {anonymous}::test; T_arg1 = double; typename sigc::type_trait<T_arg3>::take = const double&] (const struct const_volatile_mem_functor1 * const this, const struct test & _A_obj, const double & _A_a1)
{
  void test::<T8b26> (const volatile struct test *, double) * iftmp.11;
  void test::<T8b26> (const volatile struct test *, double) * D.50306;
  long int D.50307;
  long int D.50308;
  long int D.50312;
  sizetype D.50313;
  const struct test * D.50314;
  int (*__vtbl_ptr_type) () * D.50315;
  long int D.50316;
  sizetype D.50317;
  int (*__vtbl_ptr_type) () * D.50318;
  double D.50319;
  const volatile struct test * D.50320;

  D.50306 = this->func_ptr_.__pfn;
  D.50307 = (long int) D.50306;
  D.50308 = D.50307 & 1;
  if (D.50308 == 0) goto <D.50309>; else goto <D.50310>;
  <D.50309>:
  iftmp.11 = this->func_ptr_.__pfn;
  goto <D.50311>;
  <D.50310>:
  D.50312 = this->func_ptr_.__delta;
  D.50313 = (sizetype) D.50312;
  D.50314 = _A_obj + D.50313;
  D.50315 = MEM[(int (*__vtbl_ptr_type) () * *)D.50314];
  D.50306 = this->func_ptr_.__pfn;
  D.50307 = (long int) D.50306;
  D.50316 = D.50307 + -1;
  D.50317 = (sizetype) D.50316;
  D.50318 = D.50315 + D.50317;
  iftmp.11 = *D.50318;
  <D.50311>:
  D.50319 = *_A_a1;
  D.50312 = this->func_ptr_.__delta;
  D.50313 = (sizetype) D.50312;
  D.50320 = _A_obj + D.50313;
  iftmp.11 (D.50320, D.50319);
  return;
}


sigc::const_volatile_mem_functor1<T_return, T_obj, T_arg1> sigc::mem_fun(T_return (T_obj::*)(T_arg1) const volatile) [with T_arg1 = double; T_return = void; T_obj = {anonymous}::test] (struct 
{
  void test::<T8b26> (const volatile struct test *, double) * __pfn;
  long int __delta;
} _A_func)
{
  struct const_volatile_mem_functor1 D.50322;
  struct const_volatile_mem_functor1 D.49511;

  sigc::const_volatile_mem_functor1<void, {anonymous}::test, double>::const_volatile_mem_functor1 (&D.49511, _A_func);
  try
    {
      D.50322 = D.49511;
      return D.50322;
    }
  finally
    {
      D.49511 = {CLOBBER};
    }
}


sigc::const_volatile_mem_functor1<T_return, T_obj, T_arg1>::const_volatile_mem_functor1(sigc::const_volatile_mem_functor1<T_return, T_obj, T_arg1>::function_type) [with T_return = void; T_obj = {anonymous}::test; T_arg1 = double; sigc::const_volatile_mem_functor1<T_return, T_obj, T_arg1>::function_type = void ({anonymous}::test::*)(double) const volatile] (struct const_volatile_mem_functor1 * const this, struct function_type _A_func)
{
  sigc::functor_base::functor_base (this);
  this->func_ptr_ = _A_func;
}


T_return sigc::const_volatile_mem_functor1<T_return, T_obj, T_arg1>::operator()(const T_obj*, typename sigc::type_trait<T_arg3>::take) const [with T_return = void; T_obj = {anonymous}::test; T_arg1 = double; typename sigc::type_trait<T_arg3>::take = const double&] (const struct const_volatile_mem_functor1 * const this, const struct test * _A_obj, const double & _A_a1)
{
  void test::<T8b26> (const volatile struct test *, double) * iftmp.12;
  void test::<T8b26> (const volatile struct test *, double) * D.50326;
  long int D.50327;
  long int D.50328;
  long int D.50332;
  sizetype D.50333;
  const struct test * D.50334;
  int (*__vtbl_ptr_type) () * D.50335;
  long int D.50336;
  sizetype D.50337;
  int (*__vtbl_ptr_type) () * D.50338;
  double D.50339;
  const volatile struct test * D.50340;

  D.50326 = this->func_ptr_.__pfn;
  D.50327 = (long int) D.50326;
  D.50328 = D.50327 & 1;
  if (D.50328 == 0) goto <D.50329>; else goto <D.50330>;
  <D.50329>:
  iftmp.12 = this->func_ptr_.__pfn;
  goto <D.50331>;
  <D.50330>:
  D.50332 = this->func_ptr_.__delta;
  D.50333 = (sizetype) D.50332;
  D.50334 = _A_obj + D.50333;
  D.50335 = MEM[(int (*__vtbl_ptr_type) () * *)D.50334];
  D.50326 = this->func_ptr_.__pfn;
  D.50327 = (long int) D.50326;
  D.50336 = D.50327 + -1;
  D.50337 = (sizetype) D.50336;
  D.50338 = D.50335 + D.50337;
  iftmp.12 = *D.50338;
  <D.50331>:
  D.50339 = *_A_a1;
  D.50332 = this->func_ptr_.__delta;
  D.50333 = (sizetype) D.50332;
  D.50340 = _A_obj + D.50333;
  iftmp.12 (D.50340, D.50339);
  return;
}


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


sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::bound_mem_functor1(T_obj&, sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::function_type) [with T_return = void; T_obj = {anonymous}::test; T_arg1 = short int; sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::function_type = void ({anonymous}::test::*)(short int)] (struct bound_mem_functor1 * const this, struct test & _A_obj, struct function_type _A_func)
{
  struct mem_functor1 * D.50344;
  struct limit_reference * D.50345;

  D.50344 = &this->D.49080;
  sigc::mem_functor1<void, {anonymous}::test, short int>::mem_functor1 (D.50344, _A_func);
  D.50345 = &this->obj_;
  sigc::limit_reference<{anonymous}::test, false>::limit_reference (D.50345, _A_obj);
}


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


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


sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::bound_mem_functor1(T_obj*, sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::function_type) [with T_return = void; T_obj = {anonymous}::test; T_arg1 = short int; sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::function_type = void ({anonymous}::test::*)(short int)] (struct bound_mem_functor1 * const this, struct test * _A_obj, struct function_type _A_func)
{
  struct mem_functor1 * D.50348;
  struct limit_reference * D.50349;

  D.50348 = &this->D.49080;
  sigc::mem_functor1<void, {anonymous}::test, short int>::mem_functor1 (D.50348, _A_func);
  D.50349 = &this->obj_;
  sigc::limit_reference<{anonymous}::test, false>::limit_reference (D.50349, _A_obj);
}


T_return sigc::bound_mem_functor1<T_return, T_obj, T_arg1>::operator()(typename sigc::type_trait<T_arg3>::take) const [with T_return = void; T_obj = {anonymous}::test; T_arg1 = short int; typename sigc::type_trait<T_arg3>::take = const short int&] (const struct bound_mem_functor1 * const this, const short int & _A_a1)
{
  const struct limit_reference * D.50350;
  struct test & D.50351;
  void test::<T8b17> (struct test *, short int) * iftmp.13;
  void test::<T8b17> (struct test *, short int) * D.50353;
  long int D.50354;
  long int D.50355;
  long int D.50359;
  sizetype D.50360;
  struct test * D.50361;
  int (*__vtbl_ptr_type) () * D.50362;
  long int D.50363;
  sizetype D.50364;
  int (*__vtbl_ptr_type) () * D.50365;
  short int D.50366;
  int D.50367;

  D.50350 = &this->obj_;
  D.50351 = sigc::limit_reference<{anonymous}::test, false>::invoke (D.50350);
  D.50353 = this->D.49080.func_ptr_.__pfn;
  D.50354 = (long int) D.50353;
  D.50355 = D.50354 & 1;
  if (D.50355 == 0) goto <D.50356>; else goto <D.50357>;
  <D.50356>:
  iftmp.13 = this->D.49080.func_ptr_.__pfn;
  goto <D.50358>;
  <D.50357>:
  D.50359 = this->D.49080.func_ptr_.__delta;
  D.50360 = (sizetype) D.50359;
  D.50361 = D.50351 + D.50360;
  D.50362 = MEM[(int (*__vtbl_ptr_type) () * *)D.50361];
  D.50353 = this->D.49080.func_ptr_.__pfn;
  D.50354 = (long int) D.50353;
  D.50363 = D.50354 + -1;
  D.50364 = (sizetype) D.50363;
  D.50365 = D.50362 + D.50364;
  iftmp.13 = *D.50365;
  <D.50358>:
  D.50366 = *_A_a1;
  D.50367 = (int) D.50366;
  D.50359 = this->D.49080.func_ptr_.__delta;
  D.50360 = (sizetype) D.50359;
  D.50361 = D.50351 + D.50360;
  iftmp.13 (D.50361, D.50367);
  return;
}


T_type& sigc::limit_reference<T_type, I_derives_trackable>::invoke() const [with T_type = {anonymous}::test; bool I_derives_trackable = false] (const struct limit_reference * const this)
{
  struct test & D.50369;

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


sigc::bound_const_mem_functor1<T_return, T_obj, T_arg1> sigc::mem_fun(T_obj&, T_return (T_obj2::*)(T_arg1) const) [with T_arg1 = int; T_return = void; T_obj = {anonymous}::test; T_obj2 = {anonymous}::test] (struct test & _A_obj, struct 
{
  void test::<T8b1c> (const struct test *, int) * __pfn;
  long int __delta;
} _A_func)
{
  sigc::bound_const_mem_functor1<void, {anonymous}::test, int>::bound_const_mem_functor1 (&<retval>, _A_obj, _A_func);
  return <retval>;
}


sigc::bound_const_mem_functor1<T_return, T_obj, T_arg1>::bound_const_mem_functor1(const T_obj&, sigc::bound_const_mem_functor1<T_return, T_obj, T_arg1>::function_type) [with T_return = void; T_obj = {anonymous}::test; T_arg1 = int; sigc::bound_const_mem_functor1<T_return, T_obj, T_arg1>::function_type = void ({anonymous}::test::*)(int) const] (struct bound_const_mem_functor1 * const this, const struct test & _A_obj, struct function_type _A_func)
{
  struct const_mem_functor1 * D.50373;
  struct const_limit_reference * D.50374;

  D.50373 = &this->D.49152;
  sigc::const_mem_functor1<void, {anonymous}::test, int>::const_mem_functor1 (D.50373, _A_func);
  D.50374 = &this->obj_;
  sigc::const_limit_reference<{anonymous}::test, false>::const_limit_reference (D.50374, _A_obj);
}


sigc::const_limit_reference<T_type, I_derives_trackable>::const_limit_reference(const T_type&) [with T_type = {anonymous}::test; bool I_derives_trackable = false] (struct const_limit_reference * const this, const struct test & _A_target)
{
  this->visited = _A_target;
}


sigc::bound_const_mem_functor1<T_return, T_obj, T_arg1> sigc::mem_fun(T_obj*, T_return (T_obj2::*)(T_arg1) const) [with T_arg1 = int; T_return = void; T_obj = {anonymous}::test; T_obj2 = {anonymous}::test] (struct test * _A_obj, struct 
{
  void test::<T8b1c> (const struct test *, int) * __pfn;
  long int __delta;
} _A_func)
{
  sigc::bound_const_mem_functor1<void, {anonymous}::test, int>::bound_const_mem_functor1 (&<retval>, _A_obj, _A_func);
  return <retval>;
}


sigc::bound_const_mem_functor1<T_return, T_obj, T_arg1>::bound_const_mem_functor1(const T_obj*, sigc::bound_const_mem_functor1<T_return, T_obj, T_arg1>::function_type) [with T_return = void; T_obj = {anonymous}::test; T_arg1 = int; sigc::bound_const_mem_functor1<T_return, T_obj, T_arg1>::function_type = void ({anonymous}::test::*)(int) const] (struct bound_const_mem_functor1 * const this, const struct test * _A_obj, struct function_type _A_func)
{
  struct const_mem_functor1 * D.50377;
  struct const_limit_reference * D.50378;

  D.50377 = &this->D.49152;
  sigc::const_mem_functor1<void, {anonymous}::test, int>::const_mem_functor1 (D.50377, _A_func);
  D.50378 = &this->obj_;
  sigc::const_limit_reference<{anonymous}::test, false>::const_limit_reference (D.50378, _A_obj);
}


T_return sigc::bound_const_mem_functor1<T_return, T_obj, T_arg1>::operator()(typename sigc::type_trait<T_arg3>::take) const [with T_return = void; T_obj = {anonymous}::test; T_arg1 = int; typename sigc::type_trait<T_arg3>::take = const int&] (const struct bound_const_mem_functor1 * const this, const int & _A_a1)
{
  const struct const_limit_reference * D.50379;
  const struct test & D.50380;
  void test::<T8b1c> (const struct test *, int) * iftmp.14;
  void test::<T8b1c> (const struct test *, int) * D.50382;
  long int D.50383;
  long int D.50384;
  long int D.50388;
  sizetype D.50389;
  const struct test * D.50390;
  int (*__vtbl_ptr_type) () * D.50391;
  long int D.50392;
  sizetype D.50393;
  int (*__vtbl_ptr_type) () * D.50394;
  int D.50395;

  D.50379 = &this->obj_;
  D.50380 = sigc::const_limit_reference<{anonymous}::test, false>::invoke (D.50379);
  D.50382 = this->D.49152.func_ptr_.__pfn;
  D.50383 = (long int) D.50382;
  D.50384 = D.50383 & 1;
  if (D.50384 == 0) goto <D.50385>; else goto <D.50386>;
  <D.50385>:
  iftmp.14 = this->D.49152.func_ptr_.__pfn;
  goto <D.50387>;
  <D.50386>:
  D.50388 = this->D.49152.func_ptr_.__delta;
  D.50389 = (sizetype) D.50388;
  D.50390 = D.50380 + D.50389;
  D.50391 = MEM[(int (*__vtbl_ptr_type) () * *)D.50390];
  D.50382 = this->D.49152.func_ptr_.__pfn;
  D.50383 = (long int) D.50382;
  D.50392 = D.50383 + -1;
  D.50393 = (sizetype) D.50392;
  D.50394 = D.50391 + D.50393;
  iftmp.14 = *D.50394;
  <D.50387>:
  D.50395 = *_A_a1;
  D.50388 = this->D.49152.func_ptr_.__delta;
  D.50389 = (sizetype) D.50388;
  D.50390 = D.50380 + D.50389;
  iftmp.14 (D.50390, D.50395);
  return;
}


const T_type& sigc::const_limit_reference<T_type, I_derives_trackable>::invoke() const [with T_type = {anonymous}::test; bool I_derives_trackable = false] (const struct const_limit_reference * const this)
{
  const struct test & D.50397;

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


sigc::bound_volatile_mem_functor1<T_return, T_obj, T_arg1> sigc::mem_fun(T_obj&, T_return (T_obj2::*)(T_arg1) volatile) [with T_arg1 = float; T_return = void; T_obj = {anonymous}::test; T_obj2 = {anonymous}::test] (struct test & _A_obj, struct 
{
  void test::<T8b21> (volatile struct test *, float) * __pfn;
  long int __delta;
} _A_func)
{
  sigc::bound_volatile_mem_functor1<void, {anonymous}::test, float>::bound_volatile_mem_functor1 (&<retval>, _A_obj, _A_func);
  return <retval>;
}


sigc::bound_volatile_mem_functor1<T_return, T_obj, T_arg1>::bound_volatile_mem_functor1(T_obj&, sigc::bound_volatile_mem_functor1<T_return, T_obj, T_arg1>::function_type) [with T_return = void; T_obj = {anonymous}::test; T_arg1 = float; sigc::bound_volatile_mem_functor1<T_return, T_obj, T_arg1>::function_type = void ({anonymous}::test::*)(float) volatile] (struct bound_volatile_mem_functor1 * const this, struct test & _A_obj, struct function_type _A_func)
{
  struct volatile_mem_functor1 * D.50401;
  struct volatile_limit_reference * D.50402;

  D.50401 = &this->D.49224;
  sigc::volatile_mem_functor1<void, {anonymous}::test, float>::volatile_mem_functor1 (D.50401, _A_func);
  D.50402 = &this->obj_;
  sigc::volatile_limit_reference<{anonymous}::test, false>::volatile_limit_reference (D.50402, _A_obj);
}


sigc::volatile_limit_reference<T_type, I_derives_trackable>::volatile_limit_reference(T_type&) [with T_type = {anonymous}::test; bool I_derives_trackable = false] (struct volatile_limit_reference * const this, struct test & _A_target)
{
  this->visited = _A_target;
}


sigc::bound_volatile_mem_functor1<T_return, T_obj, T_arg1> sigc::mem_fun(T_obj*, T_return (T_obj2::*)(T_arg1) volatile) [with T_arg1 = float; T_return = void; T_obj = {anonymous}::test; T_obj2 = {anonymous}::test] (struct test * _A_obj, struct 
{
  void test::<T8b21> (volatile struct test *, float) * __pfn;
  long int __delta;
} _A_func)
{
  sigc::bound_volatile_mem_functor1<void, {anonymous}::test, float>::bound_volatile_mem_functor1 (&<retval>, _A_obj, _A_func);
  return <retval>;
}


sigc::bound_volatile_mem_functor1<T_return, T_obj, T_arg1>::bound_volatile_mem_functor1(T_obj*, sigc::bound_volatile_mem_functor1<T_return, T_obj, T_arg1>::function_type) [with T_return = void; T_obj = {anonymous}::test; T_arg1 = float; sigc::bound_volatile_mem_functor1<T_return, T_obj, T_arg1>::function_type = void ({anonymous}::test::*)(float) volatile] (struct bound_volatile_mem_functor1 * const this, struct test * _A_obj, struct function_type _A_func)
{
  struct volatile_mem_functor1 * D.50405;
  struct volatile_limit_reference * D.50406;

  D.50405 = &this->D.49224;
  sigc::volatile_mem_functor1<void, {anonymous}::test, float>::volatile_mem_functor1 (D.50405, _A_func);
  D.50406 = &this->obj_;
  sigc::volatile_limit_reference<{anonymous}::test, false>::volatile_limit_reference (D.50406, _A_obj);
}


T_return sigc::bound_volatile_mem_functor1<T_return, T_obj, T_arg1>::operator()(typename sigc::type_trait<T_arg3>::take) const [with T_return = void; T_obj = {anonymous}::test; T_arg1 = float; typename sigc::type_trait<T_arg3>::take = const float&] (const struct bound_volatile_mem_functor1 * const this, const float & _A_a1)
{
  const struct volatile_limit_reference * D.50407;
  volatile struct test & D.50408;
  void test::<T8b21> (volatile struct test *, float) * iftmp.15;
  void test::<T8b21> (volatile struct test *, float) * D.50410;
  long int D.50411;
  long int D.50412;
  long int D.50416;
  sizetype D.50417;
  volatile struct test * D.50418;
  int (*__vtbl_ptr_type) () * D.50419;
  long int D.50420;
  sizetype D.50421;
  int (*__vtbl_ptr_type) () * D.50422;
  float D.50423;

  D.50407 = &this->obj_;
  D.50408 = sigc::volatile_limit_reference<{anonymous}::test, false>::invoke (D.50407);
  D.50410 = this->D.49224.func_ptr_.__pfn;
  D.50411 = (long int) D.50410;
  D.50412 = D.50411 & 1;
  if (D.50412 == 0) goto <D.50413>; else goto <D.50414>;
  <D.50413>:
  iftmp.15 = this->D.49224.func_ptr_.__pfn;
  goto <D.50415>;
  <D.50414>:
  D.50416 = this->D.49224.func_ptr_.__delta;
  D.50417 = (sizetype) D.50416;
  D.50418 = D.50408 + D.50417;
  D.50419 = MEM[(int (*__vtbl_ptr_type) () * *)D.50418];
  D.50410 = this->D.49224.func_ptr_.__pfn;
  D.50411 = (long int) D.50410;
  D.50420 = D.50411 + -1;
  D.50421 = (sizetype) D.50420;
  D.50422 = D.50419 + D.50421;
  iftmp.15 = *D.50422;
  <D.50415>:
  D.50423 = *_A_a1;
  D.50416 = this->D.49224.func_ptr_.__delta;
  D.50417 = (sizetype) D.50416;
  D.50418 = D.50408 + D.50417;
  iftmp.15 (D.50418, D.50423);
  return;
}


volatile T_type& sigc::volatile_limit_reference<T_type, I_derives_trackable>::invoke() const [with T_type = {anonymous}::test; bool I_derives_trackable = false] (const struct volatile_limit_reference * const this)
{
  volatile struct test & D.50425;

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


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

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

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


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

  try
    {
      {

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


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.49464;
  struct _Rep * D.50429;
  struct _Alloc_hider * D.50430;

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


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

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

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


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

  try
    {
      {

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


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.50440;
  char * D.50441;

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


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

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


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.16;
  struct _Rep & D.50447;
  bool D.50448;
  long int D.50449;
  long int D.50450;
  bool retval.17;
  _Atomic_word * D.50454;
  int D.50455;

  D.50447 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.50448 = D.50447 != this;
  D.50449 = (long int) D.50448;
  D.50450 = __builtin_expect (D.50449, 0);
  retval.16 = D.50450 != 0;
  if (retval.16 != 0) goto <D.50451>; else goto <D.50452>;
  <D.50451>:
  D.50454 = &this->D.11865._M_refcount;
  D.50455 = __gnu_cxx::__exchange_and_add_dispatch (D.50454, -1);
  retval.17 = D.50455 <= 0;
  if (retval.17 != 0) goto <D.50456>; else goto <D.50457>;
  <D.50456>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.50458>;
  <D.50457>:
  <D.50458>:
  goto <D.50459>;
  <D.50452>:
  <D.50459>:
}


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

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


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.18;
  int D.50464;
  _Atomic_word D.50467;

  D.50464 = __gthread_active_p ();
  retval.18 = D.50464 != 0;
  if (retval.18 != 0) goto <D.50465>; else goto <D.50466>;
  <D.50465>:
  D.50467 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.50467;
  <D.50466>:
  D.50467 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.50467;
}


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

  D.50470 = __gthrw___pthread_key_create != 0B;
  D.50469 = (int) D.50470;
  return D.50469;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.50472;
  unsigned int __val.19;
  unsigned int D.50474;

  __val.19 = (unsigned int) __val;
  D.50474 = __atomic_fetch_add_4 (__mem, __val.19, 4);
  D.50472 = (_Atomic_word) D.50474;
  return D.50472;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.50476;
  int D.50477;
  _Atomic_word D.50478;
  _Atomic_word __result;

  __result = *__mem;
  D.50476 = *__mem;
  D.50477 = D.50476 + __val;
  *__mem = D.50477;
  D.50478 = __result;
  return D.50478;
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


(static initializers for test_mem_fun.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.50482>; else goto <D.50483>;
  <D.50482>:
  if (__priority == 65535) goto <D.50484>; else goto <D.50485>;
  <D.50484>:
  std::basic_ostringstream<char>::basic_ostringstream (&result_stream, 16);
  __cxa_atexit (__comp_dtor , &result_stream, &__dso_handle);
  goto <D.50486>;
  <D.50485>:
  <D.50486>:
  goto <D.50487>;
  <D.50483>:
  <D.50487>:
}


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.20;
  const void * * D.50491;
  sizetype iftmp.21;
  int (*__vtbl_ptr_type) () * D.50496;
  int (*__vtbl_ptr_type) () * D.50497;
  long int D.50498;
  struct basic_ios * D.50500;
  int (*__vtbl_ptr_type) () * iftmp.22;
  struct __stringbuf_type * D.50505;
  const void * * iftmp.23;
  struct basic_ostream * D.50510;
  int D.50511;
  struct basic_ios * D.50514;
  int D.50516;

  {
    if (2 == 0) goto <D.50489>; else goto <D.50490>;
    <D.50489>:
    D.50491 = 0B;
    iftmp.20 = *D.50491;
    goto <D.50492>;
    <D.50490>:
    iftmp.20 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
    <D.50492>:
    this->D.22312._vptr.basic_ostream = iftmp.20;
    if (2 == 0) goto <D.50494>; else goto <D.50495>;
    <D.50494>:
    D.50496 = this->D.22312._vptr.basic_ostream;
    D.50497 = D.50496 + 18446744073709551592;
    D.50498 = MEM[(long int *)D.50497];
    iftmp.21 = (sizetype) D.50498;
    goto <D.50499>;
    <D.50495>:
    iftmp.21 = 88;
    <D.50499>:
    D.50500 = this + iftmp.21;
    if (2 == 0) goto <D.50502>; else goto <D.50503>;
    <D.50502>:
    iftmp.22 = MEM[(const void * *)0B + 24B];
    goto <D.50504>;
    <D.50503>:
    iftmp.22 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
    <D.50504>:
    D.50500->D.19008._vptr.ios_base = iftmp.22;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.50505 = &this->_M_stringbuf;
                    std::basic_stringbuf<char>::~basic_stringbuf (D.50505);
                  }
              }
            finally
              {
                if (2 == 0) goto <D.50507>; else goto <D.50508>;
                <D.50507>:
                iftmp.23 = 8B;
                goto <D.50509>;
                <D.50508>:
                iftmp.23 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
                <D.50509>:
                D.50510 = &this->D.22312;
                std::basic_ostream<char>::~basic_ostream (D.50510, iftmp.23);
              }
          }
        finally
          {
            D.50511 = 2;
            if (D.50511 != 0) goto <D.50512>; else goto <D.50513>;
            <D.50512>:
            D.50514 = &this->D.22315;
            std::basic_ios<char>::~basic_ios (D.50514);
            goto <D.50515>;
            <D.50513>:
            <D.50515>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.50020>:
  D.50516 = 0;
  if (D.50516 != 0) goto <D.50517>; else goto <D.50518>;
  <D.50517>:
  operator delete (this);
  goto <D.50519>;
  <D.50518>:
  <D.50519>:
}


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


std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  struct __string_type * D.50529;
  struct basic_streambuf * D.50530;
  int D.50531;

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

              }
            finally
              {
                D.50529 = &this->_M_string;
                std::basic_string<char>::~basic_string (D.50529);
              }
          }
        finally
          {
            D.50530 = &this->D.22162;
            std::basic_streambuf<char>::~basic_streambuf (D.50530);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.49407>:
  D.50531 = 0;
  if (D.50531 != 0) goto <D.50532>; else goto <D.50533>;
  <D.50532>:
  operator delete (this);
  goto <D.50534>;
  <D.50533>:
  <D.50534>:
}


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

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

          }
        finally
          {
            D.50537 = &this->_M_buf_locale;
            std::locale::~locale (D.50537);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.49657>:
  D.50538 = 0;
  if (D.50538 != 0) goto <D.50539>; else goto <D.50540>;
  <D.50539>:
  operator delete (this);
  goto <D.50541>;
  <D.50540>:
  <D.50541>:
}


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


virtual std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  std::basic_stringbuf<char>::~basic_stringbuf (this);
  <D.49411>:
  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.24;
  sizetype iftmp.25;
  int (*__vtbl_ptr_type) () * D.50549;
  int (*__vtbl_ptr_type) () * D.50550;
  long int D.50551;
  struct basic_ios * D.50553;
  int (*__vtbl_ptr_type) () * iftmp.26;
  int D.50558;
  struct basic_ios * D.50561;
  int D.50563;

  {
    if (0 == 0) goto <D.50543>; else goto <D.50544>;
    <D.50543>:
    iftmp.24 = *__vtt_parm;
    goto <D.50545>;
    <D.50544>:
    iftmp.24 = &MEM[(void *)&_ZTVSo + 24B];
    <D.50545>:
    this->_vptr.basic_ostream = iftmp.24;
    if (0 == 0) goto <D.50547>; else goto <D.50548>;
    <D.50547>:
    D.50549 = this->_vptr.basic_ostream;
    D.50550 = D.50549 + 18446744073709551592;
    D.50551 = MEM[(long int *)D.50550];
    iftmp.25 = (sizetype) D.50551;
    goto <D.50552>;
    <D.50548>:
    iftmp.25 = 8;
    <D.50552>:
    D.50553 = this + iftmp.25;
    if (0 == 0) goto <D.50555>; else goto <D.50556>;
    <D.50555>:
    iftmp.26 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.50557>;
    <D.50556>:
    iftmp.26 = &MEM[(void *)&_ZTVSo + 64B];
    <D.50557>:
    D.50553->D.19008._vptr.ios_base = iftmp.26;
    try
      {
        try
          {

          }
        finally
          {
            D.50558 = 0;
            if (D.50558 != 0) goto <D.50559>; else goto <D.50560>;
            <D.50559>:
            D.50561 = &this->D.19694;
            std::basic_ios<char>::~basic_ios (D.50561);
            goto <D.50562>;
            <D.50560>:
            <D.50562>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.49642>:
  D.50563 = 0;
  if (D.50563 != 0) goto <D.50564>; else goto <D.50565>;
  <D.50564>:
  operator delete (this);
  goto <D.50566>;
  <D.50565>:
  <D.50566>:
}


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

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

          }
        finally
          {
            D.50568 = &this->D.19008;
            std::ios_base::~ios_base (D.50568);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.49630>:
  D.50569 = 0;
  if (D.50569 != 0) goto <D.50570>; else goto <D.50571>;
  <D.50570>:
  operator delete (this);
  goto <D.50572>;
  <D.50571>:
  <D.50572>:
}


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.49634>:
  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.50576;
  const void * * iftmp.27;
  struct basic_ostream * D.50582;
  int (*__vtbl_ptr_type) () * iftmp.28;
  const void * * D.50586;
  sizetype iftmp.29;
  int (*__vtbl_ptr_type) () * D.50591;
  int (*__vtbl_ptr_type) () * D.50592;
  long int D.50593;
  struct basic_ios * D.50595;
  int (*__vtbl_ptr_type) () * iftmp.30;
  _Ios_Openmode D.50600;
  struct __stringbuf_type * D.50601;
  struct basic_streambuf * D.50602;
  sizetype iftmp.31;
  struct basic_ios * D.50607;
  const void * * iftmp.32;

  if (1 != 0) goto <D.50574>; else goto <D.50575>;
  <D.50574>:
  D.50576 = &this->D.22315;
  std::basic_ios<char>::basic_ios (D.50576);
  goto <D.50577>;
  <D.50575>:
  <D.50577>:
  try
    {
      if (1 == 0) goto <D.50579>; else goto <D.50580>;
      <D.50579>:
      iftmp.27 = 8B;
      goto <D.50581>;
      <D.50580>:
      iftmp.27 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
      <D.50581>:
      D.50582 = &this->D.22312;
      std::basic_ostream<char>::basic_ostream (D.50582, iftmp.27);
      try
        {
          if (1 == 0) goto <D.50584>; else goto <D.50585>;
          <D.50584>:
          D.50586 = 0B;
          iftmp.28 = *D.50586;
          goto <D.50587>;
          <D.50585>:
          iftmp.28 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
          <D.50587>:
          this->D.22312._vptr.basic_ostream = iftmp.28;
          if (1 == 0) goto <D.50589>; else goto <D.50590>;
          <D.50589>:
          D.50591 = this->D.22312._vptr.basic_ostream;
          D.50592 = D.50591 + 18446744073709551592;
          D.50593 = MEM[(long int *)D.50592];
          iftmp.29 = (sizetype) D.50593;
          goto <D.50594>;
          <D.50590>:
          iftmp.29 = 88;
          <D.50594>:
          D.50595 = this + iftmp.29;
          if (1 == 0) goto <D.50597>; else goto <D.50598>;
          <D.50597>:
          iftmp.30 = MEM[(const void * *)0B + 24B];
          goto <D.50599>;
          <D.50598>:
          iftmp.30 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
          <D.50599>:
          D.50595->D.19008._vptr.ios_base = iftmp.30;
          D.50600 = std::operator| (__mode, 16);
          D.50601 = &this->_M_stringbuf;
          std::basic_stringbuf<char>::basic_stringbuf (D.50601, D.50600);
          try
            {
              D.50602 = &this->_M_stringbuf.D.22162;
              if (1 == 0) goto <D.50604>; else goto <D.50605>;
              <D.50604>:
              D.50591 = this->D.22312._vptr.basic_ostream;
              D.50592 = D.50591 + 18446744073709551592;
              D.50593 = MEM[(long int *)D.50592];
              iftmp.31 = (sizetype) D.50593;
              goto <D.50606>;
              <D.50605>:
              iftmp.31 = 88;
              <D.50606>:
              D.50607 = this + iftmp.31;
              std::basic_ios<char>::init (D.50607, D.50602);
            }
          catch
            {
              D.50601 = &this->_M_stringbuf;
              std::basic_stringbuf<char>::~basic_stringbuf (D.50601);
            }
        }
      catch
        {
          if (1 == 0) goto <D.50609>; else goto <D.50610>;
          <D.50609>:
          iftmp.32 = 8B;
          goto <D.50611>;
          <D.50610>:
          iftmp.32 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
          <D.50611>:
          D.50582 = &this->D.22312;
          std::basic_ostream<char>::~basic_ostream (D.50582, iftmp.32);
        }
    }
  catch
    {
      if (1 != 0) goto <D.50612>; else goto <D.50613>;
      <D.50612>:
      D.50576 = &this->D.22315;
      std::basic_ios<char>::~basic_ios (D.50576);
      goto <D.50614>;
      <D.50613>:
      <D.50614>:
    }
}


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

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


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.50621;
  int (*__vtbl_ptr_type) () * iftmp.33;
  sizetype iftmp.34;
  int (*__vtbl_ptr_type) () * D.50630;
  int (*__vtbl_ptr_type) () * D.50631;
  long int D.50632;
  struct basic_ios * D.50634;
  int (*__vtbl_ptr_type) () * iftmp.35;
  sizetype iftmp.36;
  struct basic_ios * D.50643;

  if (0 != 0) goto <D.50619>; else goto <D.50620>;
  <D.50619>:
  D.50621 = &this->D.19694;
  std::basic_ios<char>::basic_ios (D.50621);
  goto <D.50622>;
  <D.50620>:
  <D.50622>:
  try
    {
      if (0 == 0) goto <D.50624>; else goto <D.50625>;
      <D.50624>:
      iftmp.33 = *__vtt_parm;
      goto <D.50626>;
      <D.50625>:
      iftmp.33 = &MEM[(void *)&_ZTVSo + 24B];
      <D.50626>:
      this->_vptr.basic_ostream = iftmp.33;
      if (0 == 0) goto <D.50628>; else goto <D.50629>;
      <D.50628>:
      D.50630 = this->_vptr.basic_ostream;
      D.50631 = D.50630 + 18446744073709551592;
      D.50632 = MEM[(long int *)D.50631];
      iftmp.34 = (sizetype) D.50632;
      goto <D.50633>;
      <D.50629>:
      iftmp.34 = 8;
      <D.50633>:
      D.50634 = this + iftmp.34;
      if (0 == 0) goto <D.50636>; else goto <D.50637>;
      <D.50636>:
      iftmp.35 = MEM[(const void * *)__vtt_parm + 8B];
      goto <D.50638>;
      <D.50637>:
      iftmp.35 = &MEM[(void *)&_ZTVSo + 64B];
      <D.50638>:
      D.50634->D.19008._vptr.ios_base = iftmp.35;
      if (0 == 0) goto <D.50640>; else goto <D.50641>;
      <D.50640>:
      D.50630 = this->_vptr.basic_ostream;
      D.50631 = D.50630 + 18446744073709551592;
      D.50632 = MEM[(long int *)D.50631];
      iftmp.36 = (sizetype) D.50632;
      goto <D.50642>;
      <D.50641>:
      iftmp.36 = 8;
      <D.50642>:
      D.50643 = this + iftmp.36;
      std::basic_ios<char>::init (D.50643, 0B);
    }
  catch
    {
      if (0 != 0) goto <D.50644>; else goto <D.50645>;
      <D.50644>:
      D.50621 = &this->D.19694;
      std::basic_ios<char>::~basic_ios (D.50621);
      goto <D.50646>;
      <D.50645>:
      <D.50646>:
    }
}


std::_Ios_Openmode std::operator|(std::_Ios_Openmode, std::_Ios_Openmode) (_Ios_Openmode __a, _Ios_Openmode __b)
{
  _Ios_Openmode D.50648;
  int __a.37;
  int __b.38;
  int D.50651;

  __a.37 = (int) __a;
  __b.38 = (int) __b;
  D.50651 = __a.37 | __b.38;
  D.50648 = (_Ios_Openmode) D.50651;
  return D.50648;
}


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.50653;
  struct __string_type * D.50654;

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

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


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

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

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


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.49891;
  struct _Rep & D.50657;
  char * D.50658;
  struct _Alloc_hider * D.50659;

  std::allocator<char>::allocator (&D.49891);
  try
    {
      D.50657 = std::basic_string<char>::_S_empty_rep ();
      D.50658 = std::basic_string<char>::_Rep::_M_refdata (D.50657);
      D.50659 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.50659, D.50658, &D.49891);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.49891);
      D.49891 = {CLOBBER};
    }
  try
    {

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


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

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


_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.50665;
  void * D.50666;

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


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


