diff --git a/include/boost/type_traits/detail/is_function_ptr_tester.hpp b/include/boost/type_traits/detail/is_function_ptr_tester.hpp
index c7306a8..8ccda30 100644
--- a/include/boost/type_traits/detail/is_function_ptr_tester.hpp
+++ b/include/boost/type_traits/detail/is_function_ptr_tester.hpp
@@ -26,6 +26,8 @@
 namespace boost {
 namespace type_traits {
 
+// Note it is acceptible to use ellipsis here, since the argument will
+// always be a pointer type of some sort (JM 2005/06/04):
 no_type BOOST_TT_DECL is_function_ptr_tester(...);
 
 #if !defined(BOOST_TT_PREPROCESSING_MODE)
diff --git a/include/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp b/include/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp
index 5befeb6..282e14a 100644
--- a/include/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp
+++ b/include/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp
@@ -32,2552 +32,2552 @@ no_type BOOST_TT_DECL is_mem_fun_pointer_tester(...);
 // preprocessor-generated part, don't edit by hand!
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (T::*)());
+yes_type is_mem_fun_pointer_tester(R (T::**)());
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (T::*)() const);
+yes_type is_mem_fun_pointer_tester(R (T::**)() const);
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (T::*)() volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)() volatile);
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (T::*)() const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)() const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (T::*)( ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( ...));
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (T::*)( ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( ...) const);
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (T::*)( ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( ...) volatile);
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (T::*)( ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)());
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)());
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)() const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)() const);
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)() volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)() volatile);
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)() const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)() const volatile);
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( ...));
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( ...) const);
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( ...) volatile);
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( ...) const volatile);
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)());
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)());
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)() const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)() const);
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)() volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)() volatile);
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)() const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)() const volatile);
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( ...));
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( ...) const);
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( ...) volatile);
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( ...) const volatile);
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)());
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)());
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)() const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)() const);
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)() volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)() volatile);
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)() const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)() const volatile);
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( ...));
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( ...) const);
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( ...) volatile);
 
 template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( ...) const volatile);
 #endif
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0));
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0) const);
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0) volatile);
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 ...));
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 ...) const);
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 ...) volatile);
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0));
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0) const);
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0) volatile);
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0) const volatile);
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 ...));
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 ...) const);
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 ...) volatile);
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 ...) const volatile);
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0));
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0) const);
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0) volatile);
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0) const volatile);
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 ...));
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 ...) const);
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 ...) volatile);
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 ...) const volatile);
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0));
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0) const);
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0) volatile);
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0) const volatile);
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 ...));
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 ...) const);
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 ...) volatile);
 
 template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1));
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1) const);
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1) volatile);
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 ...));
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 ...) const);
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 ...) volatile);
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1));
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1) const);
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1) volatile);
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1) const volatile);
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 ...));
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 ...) const);
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 ...) volatile);
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1));
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1) const);
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1) volatile);
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1) const volatile);
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 ...));
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 ...) const);
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 ...) volatile);
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1));
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1) const);
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1) volatile);
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1) const volatile);
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 ...));
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 ...) const);
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 ...) volatile);
 
 template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2));
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2) const);
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2));
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2) const);
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2));
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2) const);
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2));
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2) const);
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile);
 #endif
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile);
 
 #ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile);
 #endif
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile);
 
 template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile);
 #endif
 
 #else
@@ -2602,102 +2602,102 @@ yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)( T0 , T1 , T2 , T3 , T4 , T5
 #undef __cdecl
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)));
+yes_type is_mem_fun_pointer_tester(R (T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)));
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const);
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) volatile);
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const volatile);
 
 @#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...));
+yes_type is_mem_fun_pointer_tester(R (T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...));
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const);
+yes_type is_mem_fun_pointer_tester(R (T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const);
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) volatile);
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const volatile);
 @#endif
 @#ifdef BOOST_TT_TEST_MS_FUNC_SIGS // Other calling conventions used by MS compatible compilers:
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)));
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const);
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) volatile);
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const volatile);
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...));
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...));
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const);
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) volatile);
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__stdcall T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const volatile);
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)));
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const);
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) volatile);
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const volatile);
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...));
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...));
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const);
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) volatile);
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__fastcall T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const volatile);
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)));
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const);
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) volatile);
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const volatile);
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...));
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const);
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) volatile);
 
 template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::**)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const volatile);
 @#endif
 
 #undef BOOST_PP_COUNTER
diff --git a/include/boost/type_traits/is_member_function_pointer.hpp b/include/boost/type_traits/is_member_function_pointer.hpp
index 75c13b6..1cba5bf 100644
--- a/include/boost/type_traits/is_member_function_pointer.hpp
+++ b/include/boost/type_traits/is_member_function_pointer.hpp
@@ -61,7 +61,7 @@ struct is_mem_fun_pointer_select<false>
 {
     template <typename T> struct result_
     {
-        static T& make_t;
+        static T* make_t;
         typedef result_<T> self_type;
 
         BOOST_STATIC_CONSTANT(
@@ -92,7 +92,7 @@ struct is_member_function_pointer_impl<T&> : public false_type{};
 template <typename T>
 struct is_member_function_pointer_impl
 {
-   static T& m_t;
+   static T* m_t;
    BOOST_STATIC_CONSTANT(
               bool, value =
                (1 == sizeof(type_traits::is_mem_fun_pointer_tester(m_t))) );
diff --git a/include/boost/type_traits/is_member_pointer.hpp b/include/boost/type_traits/is_member_pointer.hpp
index a3d3e32..b26436f 100644
--- a/include/boost/type_traits/is_member_pointer.hpp
+++ b/include/boost/type_traits/is_member_pointer.hpp
@@ -53,7 +53,7 @@ BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,typename U,is_member_pointer,
 namespace detail {
 
 template <typename R, typename T>
-::boost::type_traits::yes_type BOOST_TT_DECL is_member_pointer_tester(R T::*);
+::boost::type_traits::yes_type BOOST_TT_DECL is_member_pointer_tester(R T::**);
 ::boost::type_traits::no_type BOOST_TT_DECL is_member_pointer_tester(...);
 
 template <bool>
@@ -67,7 +67,7 @@ struct is_member_pointer_select<false>
 {
     template <typename T> struct result_
     {
-        static T& make_t();
+        static T* make_t();
         BOOST_STATIC_CONSTANT(
             bool, value =
             (::boost::type_traits::ice_or<
diff --git a/test/is_function_test.cpp b/test/is_function_test.cpp
index 142979f..ee28191 100644
--- a/test/is_function_test.cpp
+++ b/test/is_function_test.cpp
@@ -28,6 +28,7 @@ BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<foo4_t>::value, true);
 
 BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<void>::value, false);
 BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<int>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<int&>::value, false);
 BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<int*>::value, false);
 BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<int[]>::value, false);
 BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_function<test_abc1>::value, false);
diff --git a/test/is_member_func_test.cpp b/test/is_member_func_test.cpp
index 8cdab14..59927b4 100644
--- a/test/is_member_func_test.cpp
+++ b/test/is_member_func_test.cpp
@@ -27,6 +27,11 @@ BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<mp>::value, false
 BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<void>::value, false);
 BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<test_abc1>::value, false);
 BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<foo0_t>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<int&>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<const int&>::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<const int[2] >::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<const int[] >::value, false);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_function_pointer<void>::value, false);
 
 #ifdef BOOST_TT_TEST_MS_FUNC_SIGS
 typedef void (__stdcall test_abc1::*scall_proc)();
diff --git a/test/is_member_pointer_test.cpp b/test/is_member_pointer_test.cpp
index 02b80f8..02438d0 100644
--- a/test/is_member_pointer_test.cpp
+++ b/test/is_member_pointer_test.cpp
@@ -28,6 +28,15 @@ BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<void>::value, false);
 BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<test_abc1>::value, false);
 BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<foo0_t>::value, false);
 
+#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
+typedef void (__stdcall test_abc1::*scall_proc)();
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<scall_proc>::value, true);
+typedef void (__fastcall test_abc1::*fcall_proc)(int);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<fcall_proc>::value, true);
+typedef void (__cdecl test_abc1::*ccall_proc)(int, long, double);
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_member_pointer<ccall_proc>::value, true);
+#endif
+
 TT_TEST_END