int main(int, char**) (int argc, char * * argv)
{
  bool retval.0;
  bool D.39407;
  int D.39410;
  int iftmp.1;
  bool D.39412;
  struct compose1_functor D.38065;
  struct pointer_functor1 D.37648;
  struct bind_functor D.37621;
  struct reference_wrapper D.39416;
  struct pointer_functor3 D.36732;
  struct print D.36696;
  const struct string D.38071;
  struct allocator D.38070;
  struct compose1_functor D.38077;
  struct pointer_functor1 D.38076;
  struct bind_functor D.38075;
  struct reference_wrapper D.39417;
  struct pointer_functor3 D.38073;
  struct print D.38072;
  const struct string D.38083;
  struct allocator D.38082;
  struct compose1_functor D.38089;
  struct pointer_functor1 D.38088;
  struct bind_functor D.38087;
  struct reference_wrapper D.39418;
  struct pointer_functor3 D.38085;
  struct print D.38084;
  const struct string D.38095;
  struct allocator D.38094;
  int iftmp.2;
  bool D.39420;

  {
    struct TestUtilities * util;
    int i;
    int j;
    int k;
    struct A a;

    try
      {
        util = TestUtilities::get_instance ();
        D.39407 = TestUtilities::check_command_args (util, argc, argv);
        retval.0 = ~D.39407;
        if (retval.0 != 0) goto <D.39408>; else goto <D.39409>;
        <D.39408>:
        D.39412 = TestUtilities::get_result_and_delete_instance ();
        if (D.39412 != 0) goto <D.39413>; else goto <D.39414>;
        <D.39413>:
        iftmp.1 = 0;
        goto <D.39415>;
        <D.39414>:
        iftmp.1 = 1;
        <D.39415>:
        D.39410 = iftmp.1;
        return D.39410;
        <D.39409>:
        i = 1;
        j = 2;
        k = 3;
        {anonymous}::A::A (&a);
        std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "hit all targets: ");
        D.37648 = sigc::ptr_fun1<int, void> (bar);
        try
          {
            D.39416 = sigc::ref<{anonymous}::A> (&a);
            D.36732 = sigc::ptr_fun3<int, int, int, void> (foo);
            try
              {
                D.37621 = sigc::bind<sigc::reference_wrapper<{anonymous}::A>, int, sigc::pointer_functor3<int, int, int, void> > (&D.36732, D.39416, i); [return slot optimization]
                try
                  {
                    D.38065 = sigc::compose<sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, sigc::pointer_functor1<int, void> > (&D.37621, &D.37648); [return slot optimization]
                    try
                      {
                        try
                          {
                            sigc::visit_each<{anonymous}::print, sigc::compose1_functor<sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, sigc::pointer_functor1<int, void> > > (&D.36696, &D.38065);
                          }
                        finally
                          {
                            D.36696 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.38065 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.37621 = {CLOBBER};
                  }
              }
            finally
              {
                D.36732 = {CLOBBER};
              }
          }
        finally
          {
            D.37648 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.38070);
        try
          {
            std::basic_string<char>::basic_string (&D.38071, "hit all targets: other trackable int: 1 other ", &D.38070);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.38071);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.38071);
                D.38071 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.38070);
            D.38070 = {CLOBBER};
          }
        std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "hit all ints: ");
        D.38076 = sigc::ptr_fun1<int, void> (bar);
        try
          {
            D.39417 = sigc::ref<{anonymous}::A> (&a);
            D.38073 = sigc::ptr_fun3<int, int, int, void> (foo);
            try
              {
                D.38075 = sigc::bind<sigc::reference_wrapper<{anonymous}::A>, int, sigc::pointer_functor3<int, int, int, void> > (&D.38073, D.39417, j); [return slot optimization]
                try
                  {
                    D.38077 = sigc::compose<sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, sigc::pointer_functor1<int, void> > (&D.38075, &D.38076); [return slot optimization]
                    try
                      {
                        try
                          {
                            sigc::visit_each_type<int, {anonymous}::print, sigc::compose1_functor<sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, sigc::pointer_functor1<int, void> > > (&D.38072, &D.38077);
                          }
                        finally
                          {
                            D.38072 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.38077 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.38075 = {CLOBBER};
                  }
              }
            finally
              {
                D.38073 = {CLOBBER};
              }
          }
        finally
          {
            D.38076 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.38082);
        try
          {
            std::basic_string<char>::basic_string (&D.38083, "hit all ints: int: 2 ", &D.38082);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.38083);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.38083);
                D.38083 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.38082);
            D.38082 = {CLOBBER};
          }
        std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "hit all trackable: ");
        D.38088 = sigc::ptr_fun1<int, void> (bar);
        try
          {
            D.39418 = sigc::ref<{anonymous}::A> (&a);
            D.38085 = sigc::ptr_fun3<int, int, int, void> (foo);
            try
              {
                D.38087 = sigc::bind<sigc::reference_wrapper<{anonymous}::A>, int, sigc::pointer_functor3<int, int, int, void> > (&D.38085, D.39418, k); [return slot optimization]
                try
                  {
                    D.38089 = sigc::compose<sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, sigc::pointer_functor1<int, void> > (&D.38087, &D.38088); [return slot optimization]
                    try
                      {
                        try
                          {
                            sigc::visit_each_type<{anonymous}::trackable, {anonymous}::print, sigc::compose1_functor<sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, sigc::pointer_functor1<int, void> > > (&D.38084, &D.38089);
                          }
                        finally
                          {
                            D.38084 = {CLOBBER};
                          }
                      }
                    finally
                      {
                        D.38089 = {CLOBBER};
                      }
                  }
                finally
                  {
                    D.38087 = {CLOBBER};
                  }
              }
            finally
              {
                D.38085 = {CLOBBER};
              }
          }
        finally
          {
            D.38088 = {CLOBBER};
          }
        std::allocator<char>::allocator (&D.38094);
        try
          {
            std::basic_string<char>::basic_string (&D.38095, "hit all trackable: trackable ", &D.38094);
            try
              {
                TestUtilities::check_result (util, &result_stream, &D.38095);
              }
            finally
              {
                std::basic_string<char>::~basic_string (&D.38095);
                D.38095 = {CLOBBER};
              }
          }
        finally
          {
            std::allocator<char>::~allocator (&D.38094);
            D.38094 = {CLOBBER};
          }
        D.39420 = TestUtilities::get_result_and_delete_instance ();
        if (D.39420 != 0) goto <D.39421>; else goto <D.39422>;
        <D.39421>:
        iftmp.2 = 0;
        goto <D.39423>;
        <D.39422>:
        iftmp.2 = 1;
        <D.39423>:
        D.39410 = iftmp.2;
        return D.39410;
      }
    finally
      {
        a = {CLOBBER};
      }
  }
  D.39410 = 0;
  return D.39410;
}


void {anonymous}::foo(int, int, int) (int D.36670, int D.36671, int D.36672)
{
  GIMPLE_NOP
}


void {anonymous}::bar(int) (int D.36675)
{
  GIMPLE_NOP
}


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


{anonymous}::trackable::trackable() (struct trackable * const this)
{

}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = {anonymous}::print; T_functor = sigc::compose1_functor<sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, sigc::pointer_functor1<int, void> >] (const struct print & _A_action, const struct compose1_functor & _A_functor)
{
  sigc::visitor<sigc::compose1_functor<sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, sigc::pointer_functor1<int, void> > >::do_visit_each<{anonymous}::print> (_A_action, _A_functor);
}


static void sigc::visitor<sigc::compose1_functor<T_setter, T_getter> >::do_visit_each(const T_action&, const sigc::compose1_functor<T_setter, T_getter>&) [with T_action = {anonymous}::print; T_setter = sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_getter = sigc::pointer_functor1<int, void>] (const struct print & _A_action, const struct compose1_functor & _A_target)
{
  struct adaptor_type * D.39453;
  const struct getter_type * D.39454;

  D.39453 = &_A_target->D.38062.functor_;
  sigc::visit_each<{anonymous}::print, sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (_A_action, D.39453);
  D.39454 = &_A_target->get_;
  sigc::visit_each<{anonymous}::print, sigc::pointer_functor1<int, void> > (_A_action, D.39454);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = {anonymous}::print; T_functor = sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>] (const struct print & _A_action, const struct bind_functor & _A_functor)
{
  sigc::visitor<sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::do_visit_each<{anonymous}::print> (_A_action, _A_functor);
}


static void sigc::visitor<sigc::bind_functor<-1, T_functor, T_type1, T_type2, 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, T_type2, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_action = {anonymous}::print; T_functor = sigc::pointer_functor3<int, int, int, void>; T_type1 = sigc::reference_wrapper<{anonymous}::A>; T_type2 = int] (const struct print & _A_action, const struct bind_functor & _A_target)
{
  struct adaptor_type * D.39455;
  const struct bound_argument * D.39456;
  const struct bound_argument * D.39457;

  D.39455 = &_A_target->D.37617.functor_;
  sigc::visit_each<{anonymous}::print, sigc::adaptor_functor<sigc::pointer_functor3<int, int, int, void> > > (_A_action, D.39455);
  D.39456 = &_A_target->bound1_;
  sigc::visit_each<{anonymous}::print, sigc::bound_argument<sigc::reference_wrapper<{anonymous}::A> > > (_A_action, D.39456);
  D.39457 = &_A_target->bound2_;
  sigc::visit_each<{anonymous}::print, sigc::bound_argument<int> > (_A_action, D.39457);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = {anonymous}::print; T_functor = sigc::adaptor_functor<sigc::pointer_functor3<int, int, int, void> >] (const struct print & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::pointer_functor3<int, int, int, void> > >::do_visit_each<{anonymous}::print> (_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 = {anonymous}::print; T_functor = sigc::pointer_functor3<int, int, int, void>] (const struct print & _A_action, const struct adaptor_functor & _A_target)
{
  struct pointer_functor3 * D.39458;

  D.39458 = &_A_target->functor_;
  sigc::visit_each<{anonymous}::print, sigc::pointer_functor3<int, int, int, void> > (_A_action, D.39458);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = {anonymous}::print; T_functor = sigc::pointer_functor3<int, int, int, void>] (const struct print & _A_action, const struct pointer_functor3 & _A_functor)
{
  sigc::visitor<sigc::pointer_functor3<int, int, int, void> >::do_visit_each<{anonymous}::print> (_A_action, _A_functor);
}


static void sigc::visitor<T_functor>::do_visit_each(const T_action&, const T_functor&) [with T_action = {anonymous}::print; T_functor = sigc::pointer_functor3<int, int, int, void>] (const struct print & _A_action, const struct pointer_functor3 & _A_functor)
{
  {anonymous}::print::operator()<sigc::pointer_functor3<int, int, int, void> > (_A_action, _A_functor);
}


void {anonymous}::print::operator()(const T&) const [with T = sigc::pointer_functor3<int, int, int, void>] (const struct print * const this, const struct pointer_functor3 & t)
{
  {anonymous}::with_trackable<sigc::pointer_functor3<int, int, int, void>, false>::perform (t);
}


static void {anonymous}::with_trackable<T_type, false>::perform(const T_type&) [with T_type = sigc::pointer_functor3<int, int, int, void>] (const struct pointer_functor3 & D.39136)
{
  std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "other ");
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = {anonymous}::print; T_functor = sigc::bound_argument<sigc::reference_wrapper<{anonymous}::A> >] (const struct print & _A_action, const struct bound_argument & _A_functor)
{
  sigc::visitor<sigc::bound_argument<sigc::reference_wrapper<{anonymous}::A> > >::do_visit_each<{anonymous}::print> (_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 = {anonymous}::print; T_type = sigc::reference_wrapper<{anonymous}::A>] (const struct print & _A_action, const struct bound_argument & _A_argument)
{
  const struct limit_reference & D.39459;

  D.39459 = sigc::bound_argument<sigc::reference_wrapper<{anonymous}::A> >::visit (_A_argument);
  sigc::visit_each<{anonymous}::print, sigc::limit_reference<{anonymous}::A, false> > (_A_action, D.39459);
}


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

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


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = {anonymous}::print; T_functor = sigc::limit_reference<{anonymous}::A, false>] (const struct print & _A_action, const struct limit_reference & _A_functor)
{
  sigc::visitor<sigc::limit_reference<{anonymous}::A, false> >::do_visit_each<{anonymous}::print> (_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 = {anonymous}::print; T_type = {anonymous}::A; bool I_derives_trackable = false] (const struct print & _A_action, const struct limit_reference & _A_target)
{
  const struct A & D.39462;

  D.39462 = sigc::limit_reference<{anonymous}::A, false>::visit (_A_target);
  sigc::visit_each<{anonymous}::print, {anonymous}::A> (_A_action, D.39462);
}


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

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


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = {anonymous}::print; T_functor = {anonymous}::A] (const struct print & _A_action, const struct A & _A_functor)
{
  sigc::visitor<{anonymous}::A>::do_visit_each<{anonymous}::print> (_A_action, _A_functor);
}


static void sigc::visitor<T_functor>::do_visit_each(const T_action&, const T_functor&) [with T_action = {anonymous}::print; T_functor = {anonymous}::A] (const struct print & _A_action, const struct A & _A_functor)
{
  {anonymous}::print::operator()<{anonymous}::A> (_A_action, _A_functor);
}


void {anonymous}::print::operator()(const T&) const [with T = {anonymous}::A] (const struct print * const this, const struct A & t)
{
  {anonymous}::with_trackable<{anonymous}::A, true>::perform (t);
}


static void {anonymous}::with_trackable<T_type, true>::perform(const T_type&) [with T_type = {anonymous}::A] (const struct A & D.39264)
{
  std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "trackable ");
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = {anonymous}::print; T_functor = sigc::bound_argument<int>] (const struct print & _A_action, const struct bound_argument & _A_functor)
{
  sigc::visitor<sigc::bound_argument<int> >::do_visit_each<{anonymous}::print> (_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 = {anonymous}::print; T_type = int] (const struct print & _A_action, const struct bound_argument & _A_argument)
{
  const int & D.39465;

  D.39465 = sigc::bound_argument<int>::visit (_A_argument);
  sigc::visit_each<{anonymous}::print, int> (_A_action, D.39465);
}


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

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


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = {anonymous}::print; T_functor = int] (const struct print & _A_action, const int & _A_functor)
{
  sigc::visitor<int>::do_visit_each<{anonymous}::print> (_A_action, _A_functor);
}


static void sigc::visitor<T_functor>::do_visit_each(const T_action&, const T_functor&) [with T_action = {anonymous}::print; T_functor = int] (const struct print & _A_action, const int & _A_functor)
{
  int D.39468;

  D.39468 = *_A_functor;
  {anonymous}::print::operator() (_A_action, D.39468);
}


void {anonymous}::print::operator()(int) const (const struct print * const this, int i)
{
  struct basic_ostream & D.39469;
  struct basic_ostream & D.39470;

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


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = {anonymous}::print; T_functor = sigc::pointer_functor1<int, void>] (const struct print & _A_action, const struct pointer_functor1 & _A_functor)
{
  sigc::visitor<sigc::pointer_functor1<int, void> >::do_visit_each<{anonymous}::print> (_A_action, _A_functor);
}


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


void {anonymous}::print::operator()(const T&) const [with T = sigc::pointer_functor1<int, void>] (const struct print * const this, const struct pointer_functor1 & t)
{
  {anonymous}::with_trackable<sigc::pointer_functor1<int, void>, false>::perform (t);
}


static void {anonymous}::with_trackable<T_type, false>::perform(const T_type&) [with T_type = sigc::pointer_functor1<int, void>] (const struct pointer_functor1 & D.38913)
{
  std::operator<< <std::char_traits<char> > (&result_stream.D.22312, "other ");
}


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = int; T_action = {anonymous}::print; T_functor = sigc::compose1_functor<sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, sigc::pointer_functor1<int, void> >] (const struct print & _A_action, const struct compose1_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<int, {anonymous}::print>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<int, {anonymous}::print>, sigc::compose1_functor<sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, sigc::pointer_functor1<int, void> > > (&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 = int; T_action = {anonymous}::print] (struct limit_derived_target * const this, const struct print & _A_action)
{

}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<int, {anonymous}::print>; T_functor = sigc::compose1_functor<sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, sigc::pointer_functor1<int, void> >] (const struct limit_derived_target & _A_action, const struct compose1_functor & _A_functor)
{
  sigc::visitor<sigc::compose1_functor<sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, sigc::pointer_functor1<int, void> > >::do_visit_each<sigc::internal::limit_derived_target<int, {anonymous}::print> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::compose1_functor<T_setter, T_getter> >::do_visit_each(const T_action&, const sigc::compose1_functor<T_setter, T_getter>&) [with T_action = sigc::internal::limit_derived_target<int, {anonymous}::print>; T_setter = sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_getter = sigc::pointer_functor1<int, void>] (const struct limit_derived_target & _A_action, const struct compose1_functor & _A_target)
{
  struct adaptor_type * D.39474;
  const struct getter_type * D.39475;

  D.39474 = &_A_target->D.38062.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<int, {anonymous}::print>, sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (_A_action, D.39474);
  D.39475 = &_A_target->get_;
  sigc::visit_each<sigc::internal::limit_derived_target<int, {anonymous}::print>, sigc::pointer_functor1<int, void> > (_A_action, D.39475);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<int, {anonymous}::print>; T_functor = sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, 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, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::do_visit_each<sigc::internal::limit_derived_target<int, {anonymous}::print> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::bind_functor<-1, T_functor, T_type1, T_type2, 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, T_type2, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_action = sigc::internal::limit_derived_target<int, {anonymous}::print>; T_functor = sigc::pointer_functor3<int, int, int, void>; T_type1 = sigc::reference_wrapper<{anonymous}::A>; T_type2 = int] (const struct limit_derived_target & _A_action, const struct bind_functor & _A_target)
{
  struct adaptor_type * D.39476;
  const struct bound_argument * D.39477;
  const struct bound_argument * D.39478;

  D.39476 = &_A_target->D.37617.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<int, {anonymous}::print>, sigc::adaptor_functor<sigc::pointer_functor3<int, int, int, void> > > (_A_action, D.39476);
  D.39477 = &_A_target->bound1_;
  sigc::visit_each<sigc::internal::limit_derived_target<int, {anonymous}::print>, sigc::bound_argument<sigc::reference_wrapper<{anonymous}::A> > > (_A_action, D.39477);
  D.39478 = &_A_target->bound2_;
  sigc::visit_each<sigc::internal::limit_derived_target<int, {anonymous}::print>, sigc::bound_argument<int> > (_A_action, D.39478);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<int, {anonymous}::print>; T_functor = sigc::adaptor_functor<sigc::pointer_functor3<int, int, int, void> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::pointer_functor3<int, int, int, void> > >::do_visit_each<sigc::internal::limit_derived_target<int, {anonymous}::print> > (_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<int, {anonymous}::print>; T_functor = sigc::pointer_functor3<int, int, int, void>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct pointer_functor3 * D.39479;

  D.39479 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<int, {anonymous}::print>, sigc::pointer_functor3<int, int, int, void> > (_A_action, D.39479);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<int, {anonymous}::print>; T_functor = sigc::pointer_functor3<int, int, int, void>] (const struct limit_derived_target & _A_action, const struct pointer_functor3 & _A_functor)
{
  sigc::visitor<sigc::pointer_functor3<int, int, int, void> >::do_visit_each<sigc::internal::limit_derived_target<int, {anonymous}::print> > (_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<int, {anonymous}::print>; T_functor = sigc::pointer_functor3<int, int, int, void>] (const struct limit_derived_target & _A_action, const struct pointer_functor3 & _A_functor)
{
  sigc::internal::limit_derived_target<int, {anonymous}::print>::operator()<sigc::pointer_functor3<int, int, int, void> > (_A_action, _A_functor);
}


void sigc::internal::limit_derived_target<T_target, T_action>::operator()(const T_type&) const [with T_type = sigc::pointer_functor3<int, int, int, void>; T_target = int; T_action = {anonymous}::print] (const struct limit_derived_target * const this, const struct pointer_functor3 & _A_type)
{
  sigc::internal::with_type<false, sigc::pointer_functor3<int, int, int, void>, sigc::internal::limit_derived_target<int, {anonymous}::print> >::execute_ (_A_type, this);
}


static void sigc::internal::with_type<false, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = sigc::pointer_functor3<int, int, int, void>; T_limit = sigc::internal::limit_derived_target<int, {anonymous}::print>] (const struct pointer_functor3 & D.39201, const struct limit_derived_target & D.39202)
{
  GIMPLE_NOP
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<int, {anonymous}::print>; T_functor = sigc::bound_argument<sigc::reference_wrapper<{anonymous}::A> >] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_functor)
{
  sigc::visitor<sigc::bound_argument<sigc::reference_wrapper<{anonymous}::A> > >::do_visit_each<sigc::internal::limit_derived_target<int, {anonymous}::print> > (_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<int, {anonymous}::print>; T_type = sigc::reference_wrapper<{anonymous}::A>] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_argument)
{
  const struct limit_reference & D.39480;

  D.39480 = sigc::bound_argument<sigc::reference_wrapper<{anonymous}::A> >::visit (_A_argument);
  sigc::visit_each<sigc::internal::limit_derived_target<int, {anonymous}::print>, sigc::limit_reference<{anonymous}::A, false> > (_A_action, D.39480);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<int, {anonymous}::print>; T_functor = sigc::limit_reference<{anonymous}::A, false>] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_functor)
{
  sigc::visitor<sigc::limit_reference<{anonymous}::A, false> >::do_visit_each<sigc::internal::limit_derived_target<int, {anonymous}::print> > (_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<int, {anonymous}::print>; T_type = {anonymous}::A; bool I_derives_trackable = false] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_target)
{
  const struct A & D.39481;

  D.39481 = sigc::limit_reference<{anonymous}::A, false>::visit (_A_target);
  sigc::visit_each<sigc::internal::limit_derived_target<int, {anonymous}::print>, {anonymous}::A> (_A_action, D.39481);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<int, {anonymous}::print>; T_functor = {anonymous}::A] (const struct limit_derived_target & _A_action, const struct A & _A_functor)
{
  sigc::visitor<{anonymous}::A>::do_visit_each<sigc::internal::limit_derived_target<int, {anonymous}::print> > (_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<int, {anonymous}::print>; T_functor = {anonymous}::A] (const struct limit_derived_target & _A_action, const struct A & _A_functor)
{
  sigc::internal::limit_derived_target<int, {anonymous}::print>::operator()<{anonymous}::A> (_A_action, _A_functor);
}


void sigc::internal::limit_derived_target<T_target, T_action>::operator()(const T_type&) const [with T_type = {anonymous}::A; T_target = int; T_action = {anonymous}::print] (const struct limit_derived_target * const this, const struct A & _A_type)
{
  sigc::internal::with_type<false, {anonymous}::A, sigc::internal::limit_derived_target<int, {anonymous}::print> >::execute_ (_A_type, this);
}


static void sigc::internal::with_type<false, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = {anonymous}::A; T_limit = sigc::internal::limit_derived_target<int, {anonymous}::print>] (const struct A & D.39300, const struct limit_derived_target & D.39301)
{
  GIMPLE_NOP
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<int, {anonymous}::print>; T_functor = sigc::bound_argument<int>] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_functor)
{
  sigc::visitor<sigc::bound_argument<int> >::do_visit_each<sigc::internal::limit_derived_target<int, {anonymous}::print> > (_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<int, {anonymous}::print>; T_type = int] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_argument)
{
  const int & D.39482;

  D.39482 = sigc::bound_argument<int>::visit (_A_argument);
  sigc::visit_each<sigc::internal::limit_derived_target<int, {anonymous}::print>, int> (_A_action, D.39482);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<int, {anonymous}::print>; T_functor = int] (const struct limit_derived_target & _A_action, const int & _A_functor)
{
  sigc::visitor<int>::do_visit_each<sigc::internal::limit_derived_target<int, {anonymous}::print> > (_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<int, {anonymous}::print>; T_functor = int] (const struct limit_derived_target & _A_action, const int & _A_functor)
{
  sigc::internal::limit_derived_target<int, {anonymous}::print>::operator()<int> (_A_action, _A_functor);
}


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


static void sigc::internal::with_type<true, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = int; T_limit = sigc::internal::limit_derived_target<int, {anonymous}::print>] (const int & _A_type, const struct limit_derived_target & _A_action)
{
  int D.39483;
  const struct print * D.39484;

  D.39483 = *_A_type;
  D.39484 = &_A_action->action_;
  {anonymous}::print::operator() (D.39484, D.39483);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<int, {anonymous}::print>; T_functor = sigc::pointer_functor1<int, void>] (const struct limit_derived_target & _A_action, const struct pointer_functor1 & _A_functor)
{
  sigc::visitor<sigc::pointer_functor1<int, void> >::do_visit_each<sigc::internal::limit_derived_target<int, {anonymous}::print> > (_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<int, {anonymous}::print>; T_functor = sigc::pointer_functor1<int, void>] (const struct limit_derived_target & _A_action, const struct pointer_functor1 & _A_functor)
{
  sigc::internal::limit_derived_target<int, {anonymous}::print>::operator()<sigc::pointer_functor1<int, void> > (_A_action, _A_functor);
}


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


static void sigc::internal::with_type<false, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = sigc::pointer_functor1<int, void>; T_limit = sigc::internal::limit_derived_target<int, {anonymous}::print>] (const struct pointer_functor1 & D.38985, const struct limit_derived_target & D.38986)
{
  GIMPLE_NOP
}


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.39487;
  int (*__vtbl_ptr_type) () * D.39488;
  long int D.39489;
  sizetype D.39490;
  struct basic_ios * D.39491;
  long unsigned int D.39493;
  long int D.39494;
  struct basic_ostream & D.39495;

  if (__s == 0B) goto <D.39485>; else goto <D.39486>;
  <D.39485>:
  D.39487 = __out->_vptr.basic_ostream;
  D.39488 = D.39487 + 18446744073709551592;
  D.39489 = MEM[(long int *)D.39488];
  D.39490 = (sizetype) D.39489;
  D.39491 = __out + D.39490;
  std::basic_ios<char>::setstate (D.39491, 1);
  goto <D.39492>;
  <D.39486>:
  D.39493 = std::char_traits<char>::length (__s);
  D.39494 = (long int) D.39493;
  std::__ostream_insert<char, std::char_traits<char> > (__out, __s, D.39494);
  <D.39492>:
  D.39495 = __out;
  return D.39495;
}


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.39497;
  _Ios_Iostate D.39498;

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


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

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


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

  __a.3 = (int) __a;
  __b.4 = (int) __b;
  D.39505 = __a.3 | __b.4;
  D.39502 = (_Ios_Iostate) D.39505;
  return D.39502;
}


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

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


sigc::pointer_functor1<T_arg1, T_return> sigc::ptr_fun1(T_return (*)(T_arg1)) [with T_arg1 = int; T_return = void] (void (*<T6d73>) (int) _A_func)
{
  struct pointer_functor1 D.39509;
  struct pointer_functor1 D.38221;

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


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


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

}


sigc::reference_wrapper<T_type> sigc::ref(T_type&) [with T_type = {anonymous}::A] (struct A & v)
{
  struct reference_wrapper D.39512;
  struct reference_wrapper D.38199;

  sigc::reference_wrapper<{anonymous}::A>::reference_wrapper (&D.38199, v);
  try
    {
      D.39512 = D.38199;
      return D.39512;
    }
  finally
    {
      D.38199 = {CLOBBER};
    }
}


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


sigc::pointer_functor3<T_arg1, T_arg2, T_arg3, T_return> sigc::ptr_fun3(T_return (*)(T_arg1, T_arg2, T_arg3)) [with T_arg1 = int; T_arg2 = int; T_arg3 = int; T_return = void] (void (*<T6a37>) (int, int, int) _A_func)
{
  struct pointer_functor3 D.39515;
  struct pointer_functor3 D.38197;

  sigc::pointer_functor3<int, int, int, void>::pointer_functor3 (&D.38197, _A_func);
  try
    {
      D.39515 = D.38197;
      return D.39515;
    }
  finally
    {
      D.38197 = {CLOBBER};
    }
}


sigc::pointer_functor3<T_arg1, T_arg2, T_arg3, T_return>::pointer_functor3(sigc::pointer_functor3<T_arg1, T_arg2, T_arg3, T_return>::function_type) [with T_arg1 = int; T_arg2 = int; T_arg3 = int; T_return = void; sigc::pointer_functor3<T_arg1, T_arg2, T_arg3, T_return>::function_type = void (*)(int, int, int)] (struct pointer_functor3 * const this, void (*function_type) (int, 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::bind(const T_functor&, T_type1, T_type2) [with T_type1 = sigc::reference_wrapper<{anonymous}::A>; T_type2 = int; T_functor = sigc::pointer_functor3<int, int, int, void>] (const struct pointer_functor3 & _A_func, struct reference_wrapper _A_b1, int _A_b2)
{
  sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, 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 = sigc::pointer_functor3<int, int, int, void>; T_type1 = sigc::reference_wrapper<{anonymous}::A>; T_type2 = int; typename sigc::type_trait<T_base>::take = const sigc::pointer_functor3<int, int, int, void>&; typename sigc::type_trait<T_derived>::take = const sigc::reference_wrapper<{anonymous}::A>&; typename sigc::type_trait<T_arg3>::take = const int&] (struct bind_functor * const this, const struct pointer_functor3 & _A_func, const struct reference_wrapper & _A_bound1, const int & _A_bound2)
{
  struct adapts * D.39520;
  struct bound_argument * D.39521;
  struct bound_argument * D.39522;

  D.39520 = &this->D.37617;
  sigc::adapts<sigc::pointer_functor3<int, int, int, void> >::adapts (D.39520, _A_func);
  D.39521 = &this->bound1_;
  sigc::bound_argument<sigc::reference_wrapper<{anonymous}::A> >::bound_argument (D.39521, _A_bound1);
  D.39522 = &this->bound2_;
  sigc::bound_argument<int>::bound_argument (D.39522, _A_bound2);
}


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

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


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


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


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

  D.39524 = sigc::unwrap<{anonymous}::A> (_A_argument);
  D.39525 = &this->visited_;
  sigc::limit_reference<{anonymous}::A, false>::limit_reference (D.39525, D.39524);
}


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

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


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

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


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


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

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


sigc::compose1_functor<T_setter, T_getter> sigc::compose(const T_setter&, const T_getter&) [with T_setter = sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_getter = sigc::pointer_functor1<int, void>] (const struct bind_functor & _A_setter, const struct pointer_functor1 & _A_getter)
{
  sigc::compose1_functor<sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, sigc::pointer_functor1<int, void> >::compose1_functor (&<retval>, _A_setter, _A_getter);
  return <retval>;
}


sigc::compose1_functor<T_setter, T_getter>::compose1_functor(const T_setter&, const T_getter&) [with T_setter = sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_getter = sigc::pointer_functor1<int, void>] (struct compose1_functor * const this, const struct bind_functor & _A_setter, const struct pointer_functor1 & _A_getter)
{
  struct adapts * D.39534;

  D.39534 = &this->D.38062;
  sigc::adapts<sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::adapts (D.39534, _A_setter);
  this->get_ = *_A_getter;
}


sigc::adapts<T_functor>::adapts(const T_functor&) [with T_functor = sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, 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;
}


void sigc::visit_each_type(const T_action&, const T_functor&) [with T_type = {anonymous}::trackable; T_action = {anonymous}::print; T_functor = sigc::compose1_functor<sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, sigc::pointer_functor1<int, void> >] (const struct print & _A_action, const struct compose1_functor & _A_functor)
{
  typedef struct type_limited_action type_limited_action;
  struct type_limited_action limited_action;

  try
    {
      sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>::limit_derived_target (&limited_action, _A_action);
      sigc::visit_each<sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>, sigc::compose1_functor<sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, sigc::pointer_functor1<int, void> > > (&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 = {anonymous}::trackable; T_action = {anonymous}::print] (struct limit_derived_target * const this, const struct print & _A_action)
{

}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>; T_functor = sigc::compose1_functor<sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, sigc::pointer_functor1<int, void> >] (const struct limit_derived_target & _A_action, const struct compose1_functor & _A_functor)
{
  sigc::visitor<sigc::compose1_functor<sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>, sigc::pointer_functor1<int, void> > >::do_visit_each<sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::compose1_functor<T_setter, T_getter> >::do_visit_each(const T_action&, const sigc::compose1_functor<T_setter, T_getter>&) [with T_action = sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>; T_setter = sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>; T_getter = sigc::pointer_functor1<int, void>] (const struct limit_derived_target & _A_action, const struct compose1_functor & _A_target)
{
  struct adaptor_type * D.39536;
  const struct getter_type * D.39537;

  D.39536 = &_A_target->D.38062.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>, sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> > (_A_action, D.39536);
  D.39537 = &_A_target->get_;
  sigc::visit_each<sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>, sigc::pointer_functor1<int, void> > (_A_action, D.39537);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>; T_functor = sigc::bind_functor<-1, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, 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, sigc::pointer_functor3<int, int, int, void>, sigc::reference_wrapper<{anonymous}::A>, int, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil> >::do_visit_each<sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print> > (_A_action, _A_functor);
}


static void sigc::visitor<sigc::bind_functor<-1, T_functor, T_type1, T_type2, 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, T_type2, sigc::nil, sigc::nil, sigc::nil, sigc::nil, sigc::nil>&) [with T_action = sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>; T_functor = sigc::pointer_functor3<int, int, int, void>; T_type1 = sigc::reference_wrapper<{anonymous}::A>; T_type2 = int] (const struct limit_derived_target & _A_action, const struct bind_functor & _A_target)
{
  struct adaptor_type * D.39538;
  const struct bound_argument * D.39539;
  const struct bound_argument * D.39540;

  D.39538 = &_A_target->D.37617.functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>, sigc::adaptor_functor<sigc::pointer_functor3<int, int, int, void> > > (_A_action, D.39538);
  D.39539 = &_A_target->bound1_;
  sigc::visit_each<sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>, sigc::bound_argument<sigc::reference_wrapper<{anonymous}::A> > > (_A_action, D.39539);
  D.39540 = &_A_target->bound2_;
  sigc::visit_each<sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>, sigc::bound_argument<int> > (_A_action, D.39540);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>; T_functor = sigc::adaptor_functor<sigc::pointer_functor3<int, int, int, void> >] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_functor)
{
  sigc::visitor<sigc::adaptor_functor<sigc::pointer_functor3<int, int, int, void> > >::do_visit_each<sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print> > (_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<{anonymous}::trackable, {anonymous}::print>; T_functor = sigc::pointer_functor3<int, int, int, void>] (const struct limit_derived_target & _A_action, const struct adaptor_functor & _A_target)
{
  struct pointer_functor3 * D.39541;

  D.39541 = &_A_target->functor_;
  sigc::visit_each<sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>, sigc::pointer_functor3<int, int, int, void> > (_A_action, D.39541);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>; T_functor = sigc::pointer_functor3<int, int, int, void>] (const struct limit_derived_target & _A_action, const struct pointer_functor3 & _A_functor)
{
  sigc::visitor<sigc::pointer_functor3<int, int, int, void> >::do_visit_each<sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print> > (_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<{anonymous}::trackable, {anonymous}::print>; T_functor = sigc::pointer_functor3<int, int, int, void>] (const struct limit_derived_target & _A_action, const struct pointer_functor3 & _A_functor)
{
  sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>::operator()<sigc::pointer_functor3<int, int, int, void> > (_A_action, _A_functor);
}


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


static void sigc::internal::with_type<false, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = sigc::pointer_functor3<int, int, int, void>; T_limit = sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>] (const struct pointer_functor3 & D.39223, const struct limit_derived_target & D.39224)
{
  GIMPLE_NOP
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>; T_functor = sigc::bound_argument<sigc::reference_wrapper<{anonymous}::A> >] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_functor)
{
  sigc::visitor<sigc::bound_argument<sigc::reference_wrapper<{anonymous}::A> > >::do_visit_each<sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print> > (_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<{anonymous}::trackable, {anonymous}::print>; T_type = sigc::reference_wrapper<{anonymous}::A>] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_argument)
{
  const struct limit_reference & D.39542;

  D.39542 = sigc::bound_argument<sigc::reference_wrapper<{anonymous}::A> >::visit (_A_argument);
  sigc::visit_each<sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>, sigc::limit_reference<{anonymous}::A, false> > (_A_action, D.39542);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>; T_functor = sigc::limit_reference<{anonymous}::A, false>] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_functor)
{
  sigc::visitor<sigc::limit_reference<{anonymous}::A, false> >::do_visit_each<sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print> > (_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<{anonymous}::trackable, {anonymous}::print>; T_type = {anonymous}::A; bool I_derives_trackable = false] (const struct limit_derived_target & _A_action, const struct limit_reference & _A_target)
{
  const struct A & D.39543;

  D.39543 = sigc::limit_reference<{anonymous}::A, false>::visit (_A_target);
  sigc::visit_each<sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>, {anonymous}::A> (_A_action, D.39543);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>; T_functor = {anonymous}::A] (const struct limit_derived_target & _A_action, const struct A & _A_functor)
{
  sigc::visitor<{anonymous}::A>::do_visit_each<sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print> > (_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<{anonymous}::trackable, {anonymous}::print>; T_functor = {anonymous}::A] (const struct limit_derived_target & _A_action, const struct A & _A_functor)
{
  sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>::operator()<{anonymous}::A> (_A_action, _A_functor);
}


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


static void sigc::internal::with_type<true, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = {anonymous}::A; T_limit = sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>] (const struct A & _A_type, const struct limit_derived_target & _A_action)
{
  const struct print * D.39544;

  D.39544 = &_A_action->action_;
  {anonymous}::print::operator()<{anonymous}::A> (D.39544, _A_type);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>; T_functor = sigc::bound_argument<int>] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_functor)
{
  sigc::visitor<sigc::bound_argument<int> >::do_visit_each<sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print> > (_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<{anonymous}::trackable, {anonymous}::print>; T_type = int] (const struct limit_derived_target & _A_action, const struct bound_argument & _A_argument)
{
  const int & D.39545;

  D.39545 = sigc::bound_argument<int>::visit (_A_argument);
  sigc::visit_each<sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>, int> (_A_action, D.39545);
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>; T_functor = int] (const struct limit_derived_target & _A_action, const int & _A_functor)
{
  sigc::visitor<int>::do_visit_each<sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print> > (_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<{anonymous}::trackable, {anonymous}::print>; T_functor = int] (const struct limit_derived_target & _A_action, const int & _A_functor)
{
  sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>::operator()<int> (_A_action, _A_functor);
}


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


static void sigc::internal::with_type<false, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = int; T_limit = sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>] (const int & D.39247, const struct limit_derived_target & D.39248)
{
  GIMPLE_NOP
}


void sigc::visit_each(const T_action&, const T_functor&) [with T_action = sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>; T_functor = sigc::pointer_functor1<int, void>] (const struct limit_derived_target & _A_action, const struct pointer_functor1 & _A_functor)
{
  sigc::visitor<sigc::pointer_functor1<int, void> >::do_visit_each<sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print> > (_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<{anonymous}::trackable, {anonymous}::print>; T_functor = sigc::pointer_functor1<int, void>] (const struct limit_derived_target & _A_action, const struct pointer_functor1 & _A_functor)
{
  sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>::operator()<sigc::pointer_functor1<int, void> > (_A_action, _A_functor);
}


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


static void sigc::internal::with_type<false, T_type, T_limit>::execute_(const T_type&, const T_limit&) [with T_type = sigc::pointer_functor1<int, void>; T_limit = sigc::internal::limit_derived_target<{anonymous}::trackable, {anonymous}::print>] (const struct pointer_functor1 & D.39004, const struct limit_derived_target & D.39005)
{
  GIMPLE_NOP
}


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

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

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


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

  try
    {
      {

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


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.38280;
  struct _Rep * D.39548;
  struct _Alloc_hider * D.39549;

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


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

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

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


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

  try
    {
      {

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


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.39559;
  char * D.39560;

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


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

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


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.5;
  struct _Rep & D.39566;
  bool D.39567;
  long int D.39568;
  long int D.39569;
  bool retval.6;
  _Atomic_word * D.39573;
  int D.39574;

  D.39566 = std::basic_string<char>::_Rep::_S_empty_rep ();
  D.39567 = D.39566 != this;
  D.39568 = (long int) D.39567;
  D.39569 = __builtin_expect (D.39568, 0);
  retval.5 = D.39569 != 0;
  if (retval.5 != 0) goto <D.39570>; else goto <D.39571>;
  <D.39570>:
  D.39573 = &this->D.11865._M_refcount;
  D.39574 = __gnu_cxx::__exchange_and_add_dispatch (D.39573, -1);
  retval.6 = D.39574 <= 0;
  if (retval.6 != 0) goto <D.39575>; else goto <D.39576>;
  <D.39575>:
  std::basic_string<char>::_Rep::_M_destroy (this, __a);
  goto <D.39577>;
  <D.39576>:
  <D.39577>:
  goto <D.39578>;
  <D.39571>:
  <D.39578>:
}


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

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


_Atomic_word __gnu_cxx::__exchange_and_add_dispatch(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  bool retval.7;
  int D.39583;
  _Atomic_word D.39586;

  D.39583 = __gthread_active_p ();
  retval.7 = D.39583 != 0;
  if (retval.7 != 0) goto <D.39584>; else goto <D.39585>;
  <D.39584>:
  D.39586 = __gnu_cxx::__exchange_and_add (__mem, __val);
  return D.39586;
  <D.39585>:
  D.39586 = __gnu_cxx::__exchange_and_add_single (__mem, __val);
  return D.39586;
}


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

  D.39589 = __gthrw___pthread_key_create != 0B;
  D.39588 = (int) D.39589;
  return D.39588;
}


_Atomic_word __gnu_cxx::__exchange_and_add(volatile _Atomic_word*, int) (volatile _Atomic_word * __mem, int __val)
{
  _Atomic_word D.39591;
  unsigned int __val.8;
  unsigned int D.39593;

  __val.8 = (unsigned int) __val;
  D.39593 = __atomic_fetch_add_4 (__mem, __val.8, 4);
  D.39591 = (_Atomic_word) D.39593;
  return D.39591;
}


_Atomic_word __gnu_cxx::__exchange_and_add_single(_Atomic_word*, int) (_Atomic_word * __mem, int __val)
{
  int D.39595;
  int D.39596;
  _Atomic_word D.39597;
  _Atomic_word __result;

  __result = *__mem;
  D.39595 = *__mem;
  D.39596 = D.39595 + __val;
  *__mem = D.39596;
  D.39597 = __result;
  return D.39597;
}


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


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

  try
    {
      {
        try
          {
            try
              {

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


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

  try
    {
      {
        try
          {

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


(static initializers for test_functor_trait.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.39601>; else goto <D.39602>;
  <D.39601>:
  if (__priority == 65535) goto <D.39603>; else goto <D.39604>;
  <D.39603>:
  std::basic_ostringstream<char>::basic_ostringstream (&result_stream, 16);
  __cxa_atexit (__comp_dtor , &result_stream, &__dso_handle);
  goto <D.39605>;
  <D.39604>:
  <D.39605>:
  goto <D.39606>;
  <D.39602>:
  <D.39606>:
}


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.9;
  const void * * D.39610;
  sizetype iftmp.10;
  int (*__vtbl_ptr_type) () * D.39615;
  int (*__vtbl_ptr_type) () * D.39616;
  long int D.39617;
  struct basic_ios * D.39619;
  int (*__vtbl_ptr_type) () * iftmp.11;
  struct __stringbuf_type * D.39624;
  const void * * iftmp.12;
  struct basic_ostream * D.39629;
  int D.39630;
  struct basic_ios * D.39633;
  int D.39635;

  {
    if (2 == 0) goto <D.39608>; else goto <D.39609>;
    <D.39608>:
    D.39610 = 0B;
    iftmp.9 = *D.39610;
    goto <D.39611>;
    <D.39609>:
    iftmp.9 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
    <D.39611>:
    this->D.22312._vptr.basic_ostream = iftmp.9;
    if (2 == 0) goto <D.39613>; else goto <D.39614>;
    <D.39613>:
    D.39615 = this->D.22312._vptr.basic_ostream;
    D.39616 = D.39615 + 18446744073709551592;
    D.39617 = MEM[(long int *)D.39616];
    iftmp.10 = (sizetype) D.39617;
    goto <D.39618>;
    <D.39614>:
    iftmp.10 = 88;
    <D.39618>:
    D.39619 = this + iftmp.10;
    if (2 == 0) goto <D.39621>; else goto <D.39622>;
    <D.39621>:
    iftmp.11 = MEM[(const void * *)0B + 24B];
    goto <D.39623>;
    <D.39622>:
    iftmp.11 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
    <D.39623>:
    D.39619->D.19008._vptr.ios_base = iftmp.11;
    try
      {
        try
          {
            try
              {
                try
                  {

                  }
                finally
                  {
                    D.39624 = &this->_M_stringbuf;
                    std::basic_stringbuf<char>::~basic_stringbuf (D.39624);
                  }
              }
            finally
              {
                if (2 == 0) goto <D.39626>; else goto <D.39627>;
                <D.39626>:
                iftmp.12 = 8B;
                goto <D.39628>;
                <D.39627>:
                iftmp.12 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
                <D.39628>:
                D.39629 = &this->D.22312;
                std::basic_ostream<char>::~basic_ostream (D.39629, iftmp.12);
              }
          }
        finally
          {
            D.39630 = 2;
            if (D.39630 != 0) goto <D.39631>; else goto <D.39632>;
            <D.39631>:
            D.39633 = &this->D.22315;
            std::basic_ios<char>::~basic_ios (D.39633);
            goto <D.39634>;
            <D.39632>:
            <D.39634>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.39325>:
  D.39635 = 0;
  if (D.39635 != 0) goto <D.39636>; else goto <D.39637>;
  <D.39636>:
  operator delete (this);
  goto <D.39638>;
  <D.39637>:
  <D.39638>:
}


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


std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  struct __string_type * D.39648;
  struct basic_streambuf * D.39649;
  int D.39650;

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

              }
            finally
              {
                D.39648 = &this->_M_string;
                std::basic_string<char>::~basic_string (D.39648);
              }
          }
        finally
          {
            D.39649 = &this->D.22162;
            std::basic_streambuf<char>::~basic_streambuf (D.39649);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.38179>:
  D.39650 = 0;
  if (D.39650 != 0) goto <D.39651>; else goto <D.39652>;
  <D.39651>:
  operator delete (this);
  goto <D.39653>;
  <D.39652>:
  <D.39653>:
}


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

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

          }
        finally
          {
            D.39656 = &this->_M_buf_locale;
            std::locale::~locale (D.39656);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.38421>:
  D.39657 = 0;
  if (D.39657 != 0) goto <D.39658>; else goto <D.39659>;
  <D.39658>:
  operator delete (this);
  goto <D.39660>;
  <D.39659>:
  <D.39660>:
}


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


virtual std::basic_stringbuf<char>::~basic_stringbuf() (struct basic_stringbuf * const this)
{
  std::basic_stringbuf<char>::~basic_stringbuf (this);
  <D.38183>:
  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.13;
  sizetype iftmp.14;
  int (*__vtbl_ptr_type) () * D.39668;
  int (*__vtbl_ptr_type) () * D.39669;
  long int D.39670;
  struct basic_ios * D.39672;
  int (*__vtbl_ptr_type) () * iftmp.15;
  int D.39677;
  struct basic_ios * D.39680;
  int D.39682;

  {
    if (0 == 0) goto <D.39662>; else goto <D.39663>;
    <D.39662>:
    iftmp.13 = *__vtt_parm;
    goto <D.39664>;
    <D.39663>:
    iftmp.13 = &MEM[(void *)&_ZTVSo + 24B];
    <D.39664>:
    this->_vptr.basic_ostream = iftmp.13;
    if (0 == 0) goto <D.39666>; else goto <D.39667>;
    <D.39666>:
    D.39668 = this->_vptr.basic_ostream;
    D.39669 = D.39668 + 18446744073709551592;
    D.39670 = MEM[(long int *)D.39669];
    iftmp.14 = (sizetype) D.39670;
    goto <D.39671>;
    <D.39667>:
    iftmp.14 = 8;
    <D.39671>:
    D.39672 = this + iftmp.14;
    if (0 == 0) goto <D.39674>; else goto <D.39675>;
    <D.39674>:
    iftmp.15 = MEM[(const void * *)__vtt_parm + 8B];
    goto <D.39676>;
    <D.39675>:
    iftmp.15 = &MEM[(void *)&_ZTVSo + 64B];
    <D.39676>:
    D.39672->D.19008._vptr.ios_base = iftmp.15;
    try
      {
        try
          {

          }
        finally
          {
            D.39677 = 0;
            if (D.39677 != 0) goto <D.39678>; else goto <D.39679>;
            <D.39678>:
            D.39680 = &this->D.19694;
            std::basic_ios<char>::~basic_ios (D.39680);
            goto <D.39681>;
            <D.39679>:
            <D.39681>:
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.38406>:
  D.39682 = 0;
  if (D.39682 != 0) goto <D.39683>; else goto <D.39684>;
  <D.39683>:
  operator delete (this);
  goto <D.39685>;
  <D.39684>:
  <D.39685>:
}


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

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

          }
        finally
          {
            D.39687 = &this->D.19008;
            std::ios_base::~ios_base (D.39687);
          }
      }
    finally
      {
        *this = {CLOBBER};
      }
  }
  <D.38394>:
  D.39688 = 0;
  if (D.39688 != 0) goto <D.39689>; else goto <D.39690>;
  <D.39689>:
  operator delete (this);
  goto <D.39691>;
  <D.39690>:
  <D.39691>:
}


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.38398>:
  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.39695;
  const void * * iftmp.16;
  struct basic_ostream * D.39701;
  int (*__vtbl_ptr_type) () * iftmp.17;
  const void * * D.39705;
  sizetype iftmp.18;
  int (*__vtbl_ptr_type) () * D.39710;
  int (*__vtbl_ptr_type) () * D.39711;
  long int D.39712;
  struct basic_ios * D.39714;
  int (*__vtbl_ptr_type) () * iftmp.19;
  _Ios_Openmode D.39719;
  struct __stringbuf_type * D.39720;
  struct basic_streambuf * D.39721;
  sizetype iftmp.20;
  struct basic_ios * D.39726;
  const void * * iftmp.21;

  if (1 != 0) goto <D.39693>; else goto <D.39694>;
  <D.39693>:
  D.39695 = &this->D.22315;
  std::basic_ios<char>::basic_ios (D.39695);
  goto <D.39696>;
  <D.39694>:
  <D.39696>:
  try
    {
      if (1 == 0) goto <D.39698>; else goto <D.39699>;
      <D.39698>:
      iftmp.16 = 8B;
      goto <D.39700>;
      <D.39699>:
      iftmp.16 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
      <D.39700>:
      D.39701 = &this->D.22312;
      std::basic_ostream<char>::basic_ostream (D.39701, iftmp.16);
      try
        {
          if (1 == 0) goto <D.39703>; else goto <D.39704>;
          <D.39703>:
          D.39705 = 0B;
          iftmp.17 = *D.39705;
          goto <D.39706>;
          <D.39704>:
          iftmp.17 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 24B];
          <D.39706>:
          this->D.22312._vptr.basic_ostream = iftmp.17;
          if (1 == 0) goto <D.39708>; else goto <D.39709>;
          <D.39708>:
          D.39710 = this->D.22312._vptr.basic_ostream;
          D.39711 = D.39710 + 18446744073709551592;
          D.39712 = MEM[(long int *)D.39711];
          iftmp.18 = (sizetype) D.39712;
          goto <D.39713>;
          <D.39709>:
          iftmp.18 = 88;
          <D.39713>:
          D.39714 = this + iftmp.18;
          if (1 == 0) goto <D.39716>; else goto <D.39717>;
          <D.39716>:
          iftmp.19 = MEM[(const void * *)0B + 24B];
          goto <D.39718>;
          <D.39717>:
          iftmp.19 = &MEM[(void *)&_ZTVSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 64B];
          <D.39718>:
          D.39714->D.19008._vptr.ios_base = iftmp.19;
          D.39719 = std::operator| (__mode, 16);
          D.39720 = &this->_M_stringbuf;
          std::basic_stringbuf<char>::basic_stringbuf (D.39720, D.39719);
          try
            {
              D.39721 = &this->_M_stringbuf.D.22162;
              if (1 == 0) goto <D.39723>; else goto <D.39724>;
              <D.39723>:
              D.39710 = this->D.22312._vptr.basic_ostream;
              D.39711 = D.39710 + 18446744073709551592;
              D.39712 = MEM[(long int *)D.39711];
              iftmp.20 = (sizetype) D.39712;
              goto <D.39725>;
              <D.39724>:
              iftmp.20 = 88;
              <D.39725>:
              D.39726 = this + iftmp.20;
              std::basic_ios<char>::init (D.39726, D.39721);
            }
          catch
            {
              D.39720 = &this->_M_stringbuf;
              std::basic_stringbuf<char>::~basic_stringbuf (D.39720);
            }
        }
      catch
        {
          if (1 == 0) goto <D.39728>; else goto <D.39729>;
          <D.39728>:
          iftmp.21 = 8B;
          goto <D.39730>;
          <D.39729>:
          iftmp.21 = &MEM[(void *)&_ZTTSt19basic_ostringstreamIcSt11char_traitsIcESaIcEE + 8B];
          <D.39730>:
          D.39701 = &this->D.22312;
          std::basic_ostream<char>::~basic_ostream (D.39701, iftmp.21);
        }
    }
  catch
    {
      if (1 != 0) goto <D.39731>; else goto <D.39732>;
      <D.39731>:
      D.39695 = &this->D.22315;
      std::basic_ios<char>::~basic_ios (D.39695);
      goto <D.39733>;
      <D.39732>:
      <D.39733>:
    }
}


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

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


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.39740;
  int (*__vtbl_ptr_type) () * iftmp.22;
  sizetype iftmp.23;
  int (*__vtbl_ptr_type) () * D.39749;
  int (*__vtbl_ptr_type) () * D.39750;
  long int D.39751;
  struct basic_ios * D.39753;
  int (*__vtbl_ptr_type) () * iftmp.24;
  sizetype iftmp.25;
  struct basic_ios * D.39762;

  if (0 != 0) goto <D.39738>; else goto <D.39739>;
  <D.39738>:
  D.39740 = &this->D.19694;
  std::basic_ios<char>::basic_ios (D.39740);
  goto <D.39741>;
  <D.39739>:
  <D.39741>:
  try
    {
      if (0 == 0) goto <D.39743>; else goto <D.39744>;
      <D.39743>:
      iftmp.22 = *__vtt_parm;
      goto <D.39745>;
      <D.39744>:
      iftmp.22 = &MEM[(void *)&_ZTVSo + 24B];
      <D.39745>:
      this->_vptr.basic_ostream = iftmp.22;
      if (0 == 0) goto <D.39747>; else goto <D.39748>;
      <D.39747>:
      D.39749 = this->_vptr.basic_ostream;
      D.39750 = D.39749 + 18446744073709551592;
      D.39751 = MEM[(long int *)D.39750];
      iftmp.23 = (sizetype) D.39751;
      goto <D.39752>;
      <D.39748>:
      iftmp.23 = 8;
      <D.39752>:
      D.39753 = this + iftmp.23;
      if (0 == 0) goto <D.39755>; else goto <D.39756>;
      <D.39755>:
      iftmp.24 = MEM[(const void * *)__vtt_parm + 8B];
      goto <D.39757>;
      <D.39756>:
      iftmp.24 = &MEM[(void *)&_ZTVSo + 64B];
      <D.39757>:
      D.39753->D.19008._vptr.ios_base = iftmp.24;
      if (0 == 0) goto <D.39759>; else goto <D.39760>;
      <D.39759>:
      D.39749 = this->_vptr.basic_ostream;
      D.39750 = D.39749 + 18446744073709551592;
      D.39751 = MEM[(long int *)D.39750];
      iftmp.25 = (sizetype) D.39751;
      goto <D.39761>;
      <D.39760>:
      iftmp.25 = 8;
      <D.39761>:
      D.39762 = this + iftmp.25;
      std::basic_ios<char>::init (D.39762, 0B);
    }
  catch
    {
      if (0 != 0) goto <D.39763>; else goto <D.39764>;
      <D.39763>:
      D.39740 = &this->D.19694;
      std::basic_ios<char>::~basic_ios (D.39740);
      goto <D.39765>;
      <D.39764>:
      <D.39765>:
    }
}


std::_Ios_Openmode std::operator|(std::_Ios_Openmode, std::_Ios_Openmode) (_Ios_Openmode __a, _Ios_Openmode __b)
{
  _Ios_Openmode D.39767;
  int __a.26;
  int __b.27;
  int D.39770;

  __a.26 = (int) __a;
  __b.27 = (int) __b;
  D.39770 = __a.26 | __b.27;
  D.39767 = (_Ios_Openmode) D.39770;
  return D.39767;
}


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.39772;
  struct __string_type * D.39773;

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

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


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

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

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


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.38622;
  struct _Rep & D.39776;
  char * D.39777;
  struct _Alloc_hider * D.39778;

  std::allocator<char>::allocator (&D.38622);
  try
    {
      D.39776 = std::basic_string<char>::_S_empty_rep ();
      D.39777 = std::basic_string<char>::_Rep::_M_refdata (D.39776);
      D.39778 = &this->_M_dataplus;
      std::basic_string<char>::_Alloc_hider::_Alloc_hider (D.39778, D.39777, &D.38622);
    }
  finally
    {
      std::allocator<char>::~allocator (&D.38622);
      D.38622 = {CLOBBER};
    }
  try
    {

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


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

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


_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.39784;
  void * D.39785;

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


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


