Further macro protection by replacing _[A-Z] with _[A-Z]p

llvm-svn: 145410

1 files changed, 271 insertions, 271 deletions

diff --git a/libcxx/include/__functional_base_03 b/libcxx/include/__functional_base_03
index fabda5bc3d4..6c6ce53e6d2 100644
--- a/libcxx/include/__functional_base_03
+++ b/libcxx/include/__functional_base_03
@@ -21,9 +21,9 @@ struct __derives_from_unary_function
 private:
     struct __two {char _; char __;};
     static __two __test(...);
-    template <class _A, class _R>
-        static unary_function<_A, _R>
-        __test(const volatile unary_function<_A, _R>*);
+    template <class _Ap, class _Rp>
+        static unary_function<_Ap, _Rp>
+        __test(const volatile unary_function<_Ap, _Rp>*);
 public:
     static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
     typedef decltype(__test((_Tp*)0)) type;
@@ -35,9 +35,9 @@ struct __derives_from_binary_function
 private:
     struct __two {char _; char __;};
     static __two __test(...);
-    template <class _A1, class _A2, class _R>
-        static binary_function<_A1, _A2, _R>
-        __test(const volatile binary_function<_A1, _A2, _R>*);
+    template <class _A1, class _A2, class _Rp>
+        static binary_function<_A1, _A2, _Rp>
+        __test(const volatile binary_function<_A1, _A2, _Rp>*);
 public:
     static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
     typedef decltype(__test((_Tp*)0)) type;
@@ -88,148 +88,148 @@ struct __weak_result_type
 
 // 0 argument case
 
-template <class _R>
-struct __weak_result_type<_R ()>
+template <class _Rp>
+struct __weak_result_type<_Rp ()>
 {
-    typedef _R result_type;
+    typedef _Rp result_type;
 };
 
-template <class _R>
-struct __weak_result_type<_R (&)()>
+template <class _Rp>
+struct __weak_result_type<_Rp (&)()>
 {
-    typedef _R result_type;
+    typedef _Rp result_type;
 };
 
-template <class _R>
-struct __weak_result_type<_R (*)()>
+template <class _Rp>
+struct __weak_result_type<_Rp (*)()>
 {
-    typedef _R result_type;
+    typedef _Rp result_type;
 };
 
 // 1 argument case
 
-template <class _R, class _A1>
-struct __weak_result_type<_R (_A1)>
-    : public unary_function<_A1, _R>
+template <class _Rp, class _A1>
+struct __weak_result_type<_Rp (_A1)>
+    : public unary_function<_A1, _Rp>
 {
 };
 
-template <class _R, class _A1>
-struct __weak_result_type<_R (&)(_A1)>
-    : public unary_function<_A1, _R>
+template <class _Rp, class _A1>
+struct __weak_result_type<_Rp (&)(_A1)>
+    : public unary_function<_A1, _Rp>
 {
 };
 
-template <class _R, class _A1>
-struct __weak_result_type<_R (*)(_A1)>
-    : public unary_function<_A1, _R>
+template <class _Rp, class _A1>
+struct __weak_result_type<_Rp (*)(_A1)>
+    : public unary_function<_A1, _Rp>
 {
 };
 
-template <class _R, class _C>
-struct __weak_result_type<_R (_C::*)()>
-    : public unary_function<_C*, _R>
+template <class _Rp, class _Cp>
+struct __weak_result_type<_Rp (_Cp::*)()>
+    : public unary_function<_Cp*, _Rp>
 {
 };
 
-template <class _R, class _C>
-struct __weak_result_type<_R (_C::*)() const>
-    : public unary_function<const _C*, _R>
+template <class _Rp, class _Cp>
+struct __weak_result_type<_Rp (_Cp::*)() const>
+    : public unary_function<const _Cp*, _Rp>
 {
 };
 
-template <class _R, class _C>
-struct __weak_result_type<_R (_C::*)() volatile>
-    : public unary_function<volatile _C*, _R>
+template <class _Rp, class _Cp>
+struct __weak_result_type<_Rp (_Cp::*)() volatile>
+    : public unary_function<volatile _Cp*, _Rp>
 {
 };
 
-template <class _R, class _C>
-struct __weak_result_type<_R (_C::*)() const volatile>
-    : public unary_function<const volatile _C*, _R>
+template <class _Rp, class _Cp>
+struct __weak_result_type<_Rp (_Cp::*)() const volatile>
+    : public unary_function<const volatile _Cp*, _Rp>
 {
 };
 
 // 2 argument case
 
-template <class _R, class _A1, class _A2>
-struct __weak_result_type<_R (_A1, _A2)>
-    : public binary_function<_A1, _A2, _R>
+template <class _Rp, class _A1, class _A2>
+struct __weak_result_type<_Rp (_A1, _A2)>
+    : public binary_function<_A1, _A2, _Rp>
 {
 };
 
-template <class _R, class _A1, class _A2>
-struct __weak_result_type<_R (*)(_A1, _A2)>
-    : public binary_function<_A1, _A2, _R>
+template <class _Rp, class _A1, class _A2>
+struct __weak_result_type<_Rp (*)(_A1, _A2)>
+    : public binary_function<_A1, _A2, _Rp>
 {
 };
 
-template <class _R, class _A1, class _A2>
-struct __weak_result_type<_R (&)(_A1, _A2)>
-    : public binary_function<_A1, _A2, _R>
+template <class _Rp, class _A1, class _A2>
+struct __weak_result_type<_Rp (&)(_A1, _A2)>
+    : public binary_function<_A1, _A2, _Rp>
 {
 };
 
-template <class _R, class _C, class _A1>
-struct __weak_result_type<_R (_C::*)(_A1)>
-    : public binary_function<_C*, _A1, _R>
+template <class _Rp, class _Cp, class _A1>
+struct __weak_result_type<_Rp (_Cp::*)(_A1)>
+    : public binary_function<_Cp*, _A1, _Rp>
 {
 };
 
-template <class _R, class _C, class _A1>
-struct __weak_result_type<_R (_C::*)(_A1) const>
-    : public binary_function<const _C*, _A1, _R>
+template <class _Rp, class _Cp, class _A1>
+struct __weak_result_type<_Rp (_Cp::*)(_A1) const>
+    : public binary_function<const _Cp*, _A1, _Rp>
 {
 };
 
-template <class _R, class _C, class _A1>
-struct __weak_result_type<_R (_C::*)(_A1) volatile>
-    : public binary_function<volatile _C*, _A1, _R>
+template <class _Rp, class _Cp, class _A1>
+struct __weak_result_type<_Rp (_Cp::*)(_A1) volatile>
+    : public binary_function<volatile _Cp*, _A1, _Rp>
 {
 };
 
-template <class _R, class _C, class _A1>
-struct __weak_result_type<_R (_C::*)(_A1) const volatile>
-    : public binary_function<const volatile _C*, _A1, _R>
+template <class _Rp, class _Cp, class _A1>
+struct __weak_result_type<_Rp (_Cp::*)(_A1) const volatile>
+    : public binary_function<const volatile _Cp*, _A1, _Rp>
 {
 };
 
 // 3 or more arguments
 
-template <class _R, class _A1, class _A2, class _A3>
-struct __weak_result_type<_R (_A1, _A2, _A3)>
+template <class _Rp, class _A1, class _A2, class _A3>
+struct __weak_result_type<_Rp (_A1, _A2, _A3)>
 {
-    typedef _R result_type;
+    typedef _Rp result_type;
 };
 
-template <class _R, class _A1, class _A2, class _A3>
-struct __weak_result_type<_R (&)(_A1, _A2, _A3)>
+template <class _Rp, class _A1, class _A2, class _A3>
+struct __weak_result_type<_Rp (&)(_A1, _A2, _A3)>
 {
-    typedef _R result_type;
+    typedef _Rp result_type;
 };
 
-template <class _R, class _A1, class _A2, class _A3>
-struct __weak_result_type<_R (*)(_A1, _A2, _A3)>
+template <class _Rp, class _A1, class _A2, class _A3>
+struct __weak_result_type<_Rp (*)(_A1, _A2, _A3)>
 {
-    typedef _R result_type;
+    typedef _Rp result_type;
 };
 
-template <class _R, class _C, class _A1, class _A2>
-struct __weak_result_type<_R (_C::*)(_A1, _A2)>
+template <class _Rp, class _Cp, class _A1, class _A2>
+struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2)>
 {
-    typedef _R result_type;
+    typedef _Rp result_type;
 };
 
-template <class _R, class _C, class _A1, class _A2>
-struct __weak_result_type<_R (_C::*)(_A1, _A2) const>
+template <class _Rp, class _Cp, class _A1, class _A2>
+struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2) const>
 {
-    typedef _R result_type;
+    typedef _Rp result_type;
 };
 
-template <class _R, class _C, class _A1, class _A2>
-struct __weak_result_type<_R (_C::*)(_A1, _A2) volatile>
+template <class _Rp, class _Cp, class _A1, class _A2>
+struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2) volatile>
 {
-    typedef _R result_type;
+    typedef _Rp result_type;
 };
 
 // __invoke
@@ -297,26 +297,26 @@ struct __weak_result_type<_R (_C::*)(_A1, _A2) volatile>
 // template <class _Tp, class _A0, bool>
 // struct __ref_return1_member_data1;
 //
-// template <class _R, class _C, class _A0>
-// struct __ref_return1_member_data1<_R _C::*, _A0, true>
+// template <class _Rp, class _Cp, class _A0>
+// struct __ref_return1_member_data1<_Rp _Cp::*, _A0, true>
 // {
-//     typedef typename __apply_cv<_A0, _R>::type& type;
+//     typedef typename __apply_cv<_A0, _Rp>::type& type;
 // };
 //
-// template <class _R, class _C, class _A0>
-// struct __ref_return1_member_data1<_R _C::*, _A0, false>
+// template <class _Rp, class _Cp, class _A0>
+// struct __ref_return1_member_data1<_Rp _Cp::*, _A0, false>
 // {
 //     static _A0 __a;
-//     typedef typename __apply_cv<decltype(*__a), _R>::type& type;
+//     typedef typename __apply_cv<decltype(*__a), _Rp>::type& type;
 // };
 //
 // template <class _Tp, class _A0>
 // struct __ref_return1_member_data;
 //
-// template <class _R, class _C, class _A0>
-// struct __ref_return1_member_data<_R _C::*, _A0>
-//     : public __ref_return1_member_data1<_R _C::*, _A0,
-//                 is_same<typename remove_cv<_C>::type,
+// template <class _Rp, class _Cp, class _A0>
+// struct __ref_return1_member_data<_Rp _Cp::*, _A0>
+//     : public __ref_return1_member_data1<_Rp _Cp::*, _A0,
+//                 is_same<typename remove_cv<_Cp>::type,
 //                         typename remove_cv<typename remove_reference<_A0>::type>::type>::value>
 // {
 // };
@@ -413,528 +413,528 @@ struct __weak_result_type<_R (_C::*)(_A1, _A2) volatile>
 
 // first bullet
 
-template <class _R, class _T, class _T1>
+template <class _Rp, class _Tp, class _T1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(), _T1& __t1)
+__invoke(_Rp (_Tp::*__f)(), _T1& __t1)
 {
     return (__t1.*__f)();
 }
 
-template <class _R, class _T, class _T1, class _A0>
+template <class _Rp, class _Tp, class _T1, class _A0>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0), _T1& __t1, _A0& __a0)
+__invoke(_Rp (_Tp::*__f)(_A0), _T1& __t1, _A0& __a0)
 {
     return (__t1.*__f)(__a0);
 }
 
-template <class _R, class _T, class _T1, class _A0, class _A1>
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0, _A1), _T1& __t1, _A0& __a0, _A1& __a1)
+__invoke(_Rp (_Tp::*__f)(_A0, _A1), _T1& __t1, _A0& __a0, _A1& __a1)
 {
     return (__t1.*__f)(__a0, __a1);
 }
 
-template <class _R, class _T, class _T1, class _A0, class _A1, class _A2>
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0, _A1, _A2), _T1& __t1, _A0& __a0, _A1& __a1, _A2& __a2)
+__invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2), _T1& __t1, _A0& __a0, _A1& __a1, _A2& __a2)
 {
     return (__t1.*__f)(__a0, __a1, __a2);
 }
 
-template <class _R, class _T, class _T1>
+template <class _Rp, class _Tp, class _T1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)() const, _T1& __t1)
+__invoke(_Rp (_Tp::*__f)() const, _T1& __t1)
 {
     return (__t1.*__f)();
 }
 
-template <class _R, class _T, class _T1, class _A0>
+template <class _Rp, class _Tp, class _T1, class _A0>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0) const, _T1& __t1, _A0& __a0)
+__invoke(_Rp (_Tp::*__f)(_A0) const, _T1& __t1, _A0& __a0)
 {
     return (__t1.*__f)(__a0);
 }
 
-template <class _R, class _T, class _T1, class _A0, class _A1>
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0, _A1) const, _T1& __t1, _A0& __a0, _A1& __a1)
+__invoke(_Rp (_Tp::*__f)(_A0, _A1) const, _T1& __t1, _A0& __a0, _A1& __a1)
 {
     return (__t1.*__f)(__a0, __a1);
 }
 
-template <class _R, class _T, class _T1, class _A0, class _A1, class _A2>
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0, _A1, _A2) const, _T1& __t1, _A0& __a0, _A1& __a1, _A2& __a2)
+__invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2) const, _T1& __t1, _A0& __a0, _A1& __a1, _A2& __a2)
 {
     return (__t1.*__f)(__a0, __a1, __a2);
 }
 
-template <class _R, class _T, class _T1>
+template <class _Rp, class _Tp, class _T1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)() volatile, _T1& __t1)
+__invoke(_Rp (_Tp::*__f)() volatile, _T1& __t1)
 {
     return (__t1.*__f)();
 }
 
-template <class _R, class _T, class _T1, class _A0>
+template <class _Rp, class _Tp, class _T1, class _A0>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0) volatile, _T1& __t1, _A0& __a0)
+__invoke(_Rp (_Tp::*__f)(_A0) volatile, _T1& __t1, _A0& __a0)
 {
     return (__t1.*__f)(__a0);
 }
 
-template <class _R, class _T, class _T1, class _A0, class _A1>
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0, _A1) volatile, _T1& __t1, _A0& __a0, _A1& __a1)
+__invoke(_Rp (_Tp::*__f)(_A0, _A1) volatile, _T1& __t1, _A0& __a0, _A1& __a1)
 {
     return (__t1.*__f)(__a0, __a1);
 }
 
-template <class _R, class _T, class _T1, class _A0, class _A1, class _A2>
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0, _A1, _A2) volatile, _T1& __t1, _A0& __a0, _A1& __a1, _A2& __a2)
+__invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2) volatile, _T1& __t1, _A0& __a0, _A1& __a1, _A2& __a2)
 {
     return (__t1.*__f)(__a0, __a1, __a2);
 }
 
-template <class _R, class _T, class _T1>
+template <class _Rp, class _Tp, class _T1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)() const volatile, _T1& __t1)
+__invoke(_Rp (_Tp::*__f)() const volatile, _T1& __t1)
 {
     return (__t1.*__f)();
 }
 
-template <class _R, class _T, class _T1, class _A0>
+template <class _Rp, class _Tp, class _T1, class _A0>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0) const volatile, _T1& __t1, _A0& __a0)
+__invoke(_Rp (_Tp::*__f)(_A0) const volatile, _T1& __t1, _A0& __a0)
 {
     return (__t1.*__f)(__a0);
 }
 
-template <class _R, class _T, class _T1, class _A0, class _A1>
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0, _A1) const volatile, _T1& __t1, _A0& __a0, _A1& __a1)
+__invoke(_Rp (_Tp::*__f)(_A0, _A1) const volatile, _T1& __t1, _A0& __a0, _A1& __a1)
 {
     return (__t1.*__f)(__a0, __a1);
 }
 
-template <class _R, class _T, class _T1, class _A0, class _A1, class _A2>
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0, _A1, _A2) const volatile, _T1& __t1, _A0& __a0, _A1& __a1, _A2& __a2)
+__invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2) const volatile, _T1& __t1, _A0& __a0, _A1& __a1, _A2& __a2)
 {
     return (__t1.*__f)(__a0, __a1, __a2);
 }
 
 // second bullet
 
-template <class _R, class _T, class _T1>
+template <class _Rp, class _Tp, class _T1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    !is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(), _T1 __t1)
+__invoke(_Rp (_Tp::*__f)(), _T1 __t1)
 {
     return ((*__t1).*__f)();
 }
 
-template <class _R, class _T, class _T1, class _A0>
+template <class _Rp, class _Tp, class _T1, class _A0>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    !is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0), _T1 __t1, _A0& __a0)
+__invoke(_Rp (_Tp::*__f)(_A0), _T1 __t1, _A0& __a0)
 {
     return ((*__t1).*__f)(__a0);
 }
 
-template <class _R, class _T, class _T1, class _A0, class _A1>
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    !is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0, _A1), _T1 __t1, _A0& __a0, _A1& __a1)
+__invoke(_Rp (_Tp::*__f)(_A0, _A1), _T1 __t1, _A0& __a0, _A1& __a1)
 {
     return ((*__t1).*__f)(__a0, __a1);
 }
 
-template <class _R, class _T, class _T1, class _A0, class _A1, class _A2>
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    !is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0, _A1, _A2), _T1 __t1, _A0& __a0, _A1& __a1, _A2& __a2)
+__invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2), _T1 __t1, _A0& __a0, _A1& __a1, _A2& __a2)
 {
     return ((*__t1).*__f)(__a0, __a1, __a2);
 }
 
-template <class _R, class _T, class _T1>
+template <class _Rp, class _Tp, class _T1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    !is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)() const, _T1 __t1)
+__invoke(_Rp (_Tp::*__f)() const, _T1 __t1)
 {
     return ((*__t1).*__f)();
 }
 
-template <class _R, class _T, class _T1, class _A0>
+template <class _Rp, class _Tp, class _T1, class _A0>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    !is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0) const, _T1 __t1, _A0& __a0)
+__invoke(_Rp (_Tp::*__f)(_A0) const, _T1 __t1, _A0& __a0)
 {
     return ((*__t1).*__f)(__a0);
 }
 
-template <class _R, class _T, class _T1, class _A0, class _A1>
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    !is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0, _A1) const, _T1 __t1, _A0& __a0, _A1& __a1)
+__invoke(_Rp (_Tp::*__f)(_A0, _A1) const, _T1 __t1, _A0& __a0, _A1& __a1)
 {
     return ((*__t1).*__f)(__a0, __a1);
 }
 
-template <class _R, class _T, class _T1, class _A0, class _A1, class _A2>
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    !is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0, _A1, _A2) const, _T1 __t1, _A0& __a0, _A1& __a1, _A2& __a2)
+__invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2) const, _T1 __t1, _A0& __a0, _A1& __a1, _A2& __a2)
 {
     return ((*__t1).*__f)(__a0, __a1, __a2);
 }
 
-template <class _R, class _T, class _T1>
+template <class _Rp, class _Tp, class _T1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    !is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)() volatile, _T1 __t1)
+__invoke(_Rp (_Tp::*__f)() volatile, _T1 __t1)
 {
     return ((*__t1).*__f)();
 }
 
-template <class _R, class _T, class _T1, class _A0>
+template <class _Rp, class _Tp, class _T1, class _A0>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    !is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0) volatile, _T1 __t1, _A0& __a0)
+__invoke(_Rp (_Tp::*__f)(_A0) volatile, _T1 __t1, _A0& __a0)
 {
     return ((*__t1).*__f)(__a0);
 }
 
-template <class _R, class _T, class _T1, class _A0, class _A1>
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    !is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0, _A1) volatile, _T1 __t1, _A0& __a0, _A1& __a1)
+__invoke(_Rp (_Tp::*__f)(_A0, _A1) volatile, _T1 __t1, _A0& __a0, _A1& __a1)
 {
     return ((*__t1).*__f)(__a0, __a1);
 }
 
-template <class _R, class _T, class _T1, class _A0, class _A1, class _A2>
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    !is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0, _A1, _A2) volatile, _T1 __t1, _A0& __a0, _A1& __a1, _A2& __a2)
+__invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2) volatile, _T1 __t1, _A0& __a0, _A1& __a1, _A2& __a2)
 {
     return ((*__t1).*__f)(__a0, __a1, __a2);
 }
 
-template <class _R, class _T, class _T1>
+template <class _Rp, class _Tp, class _T1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    !is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)() const volatile, _T1 __t1)
+__invoke(_Rp (_Tp::*__f)() const volatile, _T1 __t1)
 {
     return ((*__t1).*__f)();
 }
 
-template <class _R, class _T, class _T1, class _A0>
+template <class _Rp, class _Tp, class _T1, class _A0>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    !is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0) const volatile, _T1 __t1, _A0& __a0)
+__invoke(_Rp (_Tp::*__f)(_A0) const volatile, _T1 __t1, _A0& __a0)
 {
     return ((*__t1).*__f)(__a0);
 }
 
-template <class _R, class _T, class _T1, class _A0, class _A1>
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    !is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0, _A1) const volatile, _T1 __t1, _A0& __a0, _A1& __a1)
+__invoke(_Rp (_Tp::*__f)(_A0, _A1) const volatile, _T1 __t1, _A0& __a0, _A1& __a1)
 {
     return ((*__t1).*__f)(__a0, __a1);
 }
 
-template <class _R, class _T, class _T1, class _A0, class _A1, class _A2>
+template <class _Rp, class _Tp, class _T1, class _A0, class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    !is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    _R
+    !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    _Rp
 >::type
-__invoke(_R (_T::*__f)(_A0, _A1, _A2) const volatile, _T1 __t1, _A0& __a0, _A1& __a1, _A2& __a2)
+__invoke(_Rp (_Tp::*__f)(_A0, _A1, _A2) const volatile, _T1 __t1, _A0& __a0, _A1& __a1, _A2& __a2)
 {
     return ((*__t1).*__f)(__a0, __a1, __a2);
 }
 
 // third bullet
 
-template <class _R, class _T, class _T1>
+template <class _Rp, class _Tp, class _T1>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_base_of<_T, typename remove_reference<_T1>::type>::value,
-    typename __apply_cv<_T1, _R>::type&
+    is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+    typename __apply_cv<_T1, _Rp>::type&
 >::type
-__invoke(_R _T::* __f, _T1& __t1)
+__invoke(_Rp _Tp::* __f, _T1& __t1)
 {
     return __t1.*__f;
 }
 
-template <class _R, class _T>
+template <class _Rp, class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-__invoke(_R _T::*)
+__invoke(_Rp _Tp::*)
 {
 }
 
-// template <class _D, class _R, class _T, class _T1>
+// template <class _Dp, class _Rp, class _Tp, class _T1>
 // inline _LIBCPP_INLINE_VISIBILITY
 // typename enable_if
 // <
-//     is_base_of<_T, typename remove_reference<_T1>::type>::value,
-//     typename __ref_return1<_R _T::*, _T1>::type
+//     is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+//     typename __ref_return1<_Rp _Tp::*, _T1>::type
 // >::type
-// __invoke(_R _T::* __f, _T1& __t1)
+// __invoke(_Rp _Tp::* __f, _T1& __t1)
 // {
 //     return __t1.*__f;
 // }
 
 // forth bullet
 
-template <class _T1, class _R, bool>
+template <class _T1, class _Rp, bool>
 struct __4th_helper
 {
 };
 
-template <class _T1, class _R>
-struct __4th_helper<_T1, _R, true>
+template <class _T1, class _Rp>
+struct __4th_helper<_T1, _Rp, true>
 {
-    typedef typename __apply_cv<decltype(*_VSTD::declval<_T1>()), _R>::type type;
+    typedef typename __apply_cv<decltype(*_VSTD::declval<_T1>()), _Rp>::type type;
 };
 
-template <class _R, class _T, class _T1>
+template <class _Rp, class _Tp, class _T1>
 inline _LIBCPP_INLINE_VISIBILITY
-typename __4th_helper<_T1, _R,
-                      !is_base_of<_T,
+typename __4th_helper<_T1, _Rp,
+                      !is_base_of<_Tp,
                                   typename remove_reference<_T1>::type
                                  >::value
                      >::type&
-__invoke(_R _T::* __f, _T1& __t1)
+__invoke(_Rp _Tp::* __f, _T1& __t1)
 {
     return (*__t1).*__f;
 }
 
-// template <class _D, class _R, class _T, class _T1>
+// template <class _Dp, class _Rp, class _Tp, class _T1>
 // inline _LIBCPP_INLINE_VISIBILITY
 // typename enable_if
 // <
-//     !is_base_of<_T, typename remove_reference<_T1>::type>::value,
-//     typename __ref_return1<_R _T::*, _T1>::type
+//     !is_base_of<_Tp, typename remove_reference<_T1>::type>::value,
+//     typename __ref_return1<_Rp _Tp::*, _T1>::type
 // >::type
-// __invoke(_R _T::* __f, _T1 __t1)
+// __invoke(_Rp _Tp::* __f, _T1 __t1)
 // {
 //     return (*__t1).*__f;
 // }
 
 // fifth bullet
 
-template <class _F>
+template <class _Fp>
 inline _LIBCPP_INLINE_VISIBILITY
-decltype(declval<_F>()())
-__invoke(_F __f)
+decltype(declval<_Fp>()())
+__invoke(_Fp __f)
 {
     return __f();
 }
 
-template <class _F, class _A0>
+template <class _Fp, class _A0>
 inline _LIBCPP_INLINE_VISIBILITY
-decltype(declval<_F>()(declval<_A0&>()))
-__invoke(_F __f, _A0& __a0)
+decltype(declval<_Fp>()(declval<_A0&>()))
+__invoke(_Fp __f, _A0& __a0)
 {
     return __f(__a0);
 }
 
-template <class _F, class _A0, class _A1>
+template <class _Fp, class _A0, class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
-decltype(declval<_F>()(declval<_A0&>(), declval<_A1&>()))
-__invoke(_F __f, _A0& __a0, _A1& __a1)
+decltype(declval<_Fp>()(declval<_A0&>(), declval<_A1&>()))
+__invoke(_Fp __f, _A0& __a0, _A1& __a1)
 {
     return __f(__a0, __a1);
 }
 
-template <class _F, class _A0, class _A1, class _A2>
+template <class _Fp, class _A0, class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
-decltype(declval<_F>()(declval<_A0&>(), declval<_A1&>(), declval<_A2&>()))
-__invoke(_F __f, _A0& __a0, _A1& __a1, _A2& __a2)
+decltype(declval<_Fp>()(declval<_A0&>(), declval<_A1&>(), declval<_A2&>()))
+__invoke(_Fp __f, _A0& __a0, _A1& __a1, _A2& __a2)
 {
     return __f(__a0, __a1, __a2);
 }
 
-// template <class _R, class _F>
+// template <class _Rp, class _Fp>
 // inline _LIBCPP_INLINE_VISIBILITY
-// _R
-// __invoke(_F& __f)
+// _Rp
+// __invoke(_Fp& __f)
 // {
 //     return __f();
 // }
 //
-// template <class _R, class _F, class _A0>
+// template <class _Rp, class _Fp, class _A0>
 // inline _LIBCPP_INLINE_VISIBILITY
 // typename enable_if
 // <
-//     !is_member_pointer<_F>::value,
-//     _R
+//     !is_member_pointer<_Fp>::value,
+//     _Rp
 // >::type
-// __invoke(_F& __f, _A0& __a0)
+// __invoke(_Fp& __f, _A0& __a0)
 // {
 //     return __f(__a0);
 // }
 //
-// template <class _R, class _F, class _A0, class _A1>
+// template <class _Rp, class _Fp, class _A0, class _A1>
 // inline _LIBCPP_INLINE_VISIBILITY
-// _R
-// __invoke(_F& __f, _A0& __a0, _A1& __a1)
+// _Rp
+// __invoke(_Fp& __f, _A0& __a0, _A1& __a1)
 // {
 //     return __f(__a0, __a1);
 // }
 //
-// template <class _R, class _F, class _A0, class _A1, class _A2>
+// template <class _Rp, class _Fp, class _A0, class _A1, class _A2>
 // inline _LIBCPP_INLINE_VISIBILITY
-// _R
-// __invoke(_F& __f, _A0& __a0, _A1& __a1, _A2& __a2)
+// _Rp
+// __invoke(_Fp& __f, _A0& __a0, _A1& __a1, _A2& __a2)
 // {
 //     return __f(__a0, __a1, __a2);
 // }
@@ -950,16 +950,16 @@ public:
     static const bool value = sizeof(__test<_Tp>(0)) == 1;
 };
 
-template <class _F, bool = __has_result_type<__weak_result_type<_F> >::value>
+template <class _Fp, bool = __has_result_type<__weak_result_type<_Fp> >::value>
 struct __invoke_return
 {
-    typedef typename __weak_result_type<_F>::result_type type;
+    typedef typename __weak_result_type<_Fp>::result_type type;
 };
 
-template <class _F>
-struct __invoke_return<_F, false>
+template <class _Fp>
+struct __invoke_return<_Fp, false>
 {
-    typedef decltype(__invoke(_VSTD::declval<_F>())) type;
+    typedef decltype(__invoke(_VSTD::declval<_Fp>())) type;
 };
 
 template <class _Tp, class _A0>
@@ -968,16 +968,16 @@ struct __invoke_return0
     typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_A0>())) type;
 };
 
-template <class _R, class _T, class _A0>
-struct __invoke_return0<_R _T::*, _A0>
+template <class _Rp, class _Tp, class _A0>
+struct __invoke_return0<_Rp _Tp::*, _A0>
 {
-    typedef typename __apply_cv<_A0, _R>::type& type;
+    typedef typename __apply_cv<_A0, _Rp>::type& type;
 };
 
-template <class _R, class _T, class _A0>
-struct __invoke_return0<_R _T::*, _A0*>
+template <class _Rp, class _Tp, class _A0>
+struct __invoke_return0<_Rp _Tp::*, _A0*>
 {
-    typedef typename __apply_cv<_A0, _R>::type& type;
+    typedef typename __apply_cv<_A0, _Rp>::type& type;
 };
 
 template <class _Tp, class _A0, class _A1>