From 463f513c23724e893fbb2ef92e34c288f0134af9 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@pdimov.com>
Date: Tue, 20 Nov 2001 17:05:56 +0000
Subject: [PATCH] Major fixes to address regression failures

[SVN r11746]
---
 include/boost/bind.hpp                 |  266 +----
 include/boost/bind/bind_cc.hpp         |   64 +-
 include/boost/bind/bind_mf_cc.hpp      |   76 +-
 include/boost/bind/mem_fn_cc.hpp       |   76 +-
 include/boost/bind/mem_fn_template.hpp |  575 ++++++++++
 include/boost/bind/mem_fn_vw.hpp       |  132 +++
 include/boost/mem_fn.hpp               | 1401 ++----------------------
 7 files changed, 936 insertions(+), 1654 deletions(-)
 create mode 100644 include/boost/bind/mem_fn_template.hpp
 create mode 100644 include/boost/bind/mem_fn_vw.hpp

diff --git a/include/boost/bind.hpp b/include/boost/bind.hpp
index 7cd0107..195ac8a 100644
--- a/include/boost/bind.hpp
+++ b/include/boost/bind.hpp
@@ -1109,7 +1109,7 @@ template<class R, class F, class L> class bind_t
 
 // add_value
 
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || (__SUNPRO_CC+0 >= 0x530)
 
 template<class T> struct add_value
 {
@@ -1138,9 +1138,9 @@ template<class R, class F, class L> struct add_value< bind_t<R, F, L> >
 
 #else
 
-// template<int I> struct _avt_0;
+template<int I> struct _avt_0;
 
-template<int I> struct _avt_0 // <1>
+template<> struct _avt_0<1>
 {
     template<class T> struct inner
     {
@@ -1444,249 +1444,59 @@ template<class F, class A1, class A2, class A3, class A4, class A5, class A6, cl
 
 // function pointers
 
-#if defined(BOOST_BIND_ENABLE_STDCALL)
-#define BOOST_BIND_CC __stdcall
+#define BOOST_BIND_CC
+#define BOOST_BIND_ST
+
 #include <boost/bind/bind_cc.hpp>
+
 #undef BOOST_BIND_CC
+#undef BOOST_BIND_ST
+
+#ifdef BOOST_BIND_ENABLE_STDCALL
+
+#define BOOST_BIND_CC __stdcall
+#define BOOST_BIND_ST
+
+#include <boost/bind/bind_cc.hpp>
+
+#undef BOOST_BIND_CC
+#undef BOOST_BIND_ST
+
 #endif
 
+#ifdef BOOST_BIND_ENABLE_PASCAL
+
+#define BOOST_BIND_ST pascal
 #define BOOST_BIND_CC
+
 #include <boost/bind/bind_cc.hpp>
+
+#undef BOOST_BIND_ST
 #undef BOOST_BIND_CC
 
+#endif
+
 // member function pointers
 
-// MSVC 7.0 and Metrowerks 7.1 can't handle the "main line"
-
-#if defined(BOOST_MEM_FN_ENABLE_STDCALL) || (defined(BOOST_MSVC) && BOOST_MSVC <= 1300)  || (defined(__MWERKS__) && (__MWERKS__ <= 0x2406))
-
-#if defined(BOOST_MEM_FN_ENABLE_STDCALL)
-#define BOOST_BIND_MF_CC __stdcall
-#include <boost/bind/bind_mf_cc.hpp>
-#undef BOOST_BIND_MF_CC
-#endif
-
+#define BOOST_BIND_MF_NAME(X) X
 #define BOOST_BIND_MF_CC
+
 #include <boost/bind/bind_mf_cc.hpp>
+
+#undef BOOST_BIND_MF_NAME
 #undef BOOST_BIND_MF_CC
 
-#else
+#ifdef BOOST_MEM_FN_ENABLE_STDCALL
 
-// 0
+#define BOOST_BIND_MF_NAME(X) X##_stdcall
+#define BOOST_BIND_MF_CC __stdcall
 
-template<class R, class T,
-    class A1>
-    _bi::bind_t<R, _mfi::mf0<R, T>, typename _bi::list_av_1<A1>::type>
-    BOOST_BIND(R (T::*f) (), A1 a1)
-{
-    typedef _mfi::mf0<R, T> F;
-    typedef typename _bi::list_av_1<A1>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
-}
+#include <boost/bind/bind_mf_cc.hpp>
 
-template<class R, class T,
-    class A1>
-    _bi::bind_t<R, _mfi::cmf0<R, T>, typename _bi::list_av_1<A1>::type>
-    BOOST_BIND(R (T::*f) () const, A1 a1)
-{
-    typedef _mfi::cmf0<R, T> F;
-    typedef typename _bi::list_av_1<A1>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
-}
+#undef BOOST_BIND_MF_NAME
+#undef BOOST_BIND_MF_CC
 
-// 1
-
-template<class R, class T,
-    class B1,
-    class A1, class A2>
-    _bi::bind_t<R, _mfi::mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
-    BOOST_BIND(R (T::*f) (B1), A1 a1, A2 a2)
-{
-    typedef _mfi::mf1<R, T, B1> F;
-    typedef typename _bi::list_av_2<A1, A2>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
-}
-
-template<class R, class T,
-    class B1,
-    class A1, class A2>
-    _bi::bind_t<R, _mfi::cmf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
-    BOOST_BIND(R (T::*f) (B1) const, A1 a1, A2 a2)
-{
-    typedef _mfi::cmf1<R, T, B1> F;
-    typedef typename _bi::list_av_2<A1, A2>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
-}
-
-// 2
-
-template<class R, class T,
-    class B1, class B2,
-    class A1, class A2, class A3>
-    _bi::bind_t<R, _mfi::mf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
-    BOOST_BIND(R (T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
-{
-    typedef _mfi::mf2<R, T, B1, B2> F;
-    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
-}
-
-template<class R, class T,
-    class B1, class B2,
-    class A1, class A2, class A3>
-    _bi::bind_t<R, _mfi::cmf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
-    BOOST_BIND(R (T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
-{
-    typedef _mfi::cmf2<R, T, B1, B2> F;
-    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
-}
-
-// 3
-
-template<class R, class T,
-    class B1, class B2, class B3,
-    class A1, class A2, class A3, class A4>
-    _bi::bind_t<R, _mfi::mf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
-    BOOST_BIND(R (T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
-{
-    typedef _mfi::mf3<R, T, B1, B2, B3> F;
-    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
-}
-
-template<class R, class T,
-    class B1, class B2, class B3,
-    class A1, class A2, class A3, class A4>
-    _bi::bind_t<R, _mfi::cmf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
-    BOOST_BIND(R (T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
-{
-    typedef _mfi::cmf3<R, T, B1, B2, B3> F;
-    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
-}
-
-// 4
-
-template<class R, class T,
-    class B1, class B2, class B3, class B4,
-    class A1, class A2, class A3, class A4, class A5>
-    _bi::bind_t<R, _mfi::mf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
-    BOOST_BIND(R (T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
-{
-    typedef _mfi::mf4<R, T, B1, B2, B3, B4> F;
-    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
-}
-
-template<class R, class T,
-    class B1, class B2, class B3, class B4,
-    class A1, class A2, class A3, class A4, class A5>
-    _bi::bind_t<R, _mfi::cmf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
-    BOOST_BIND(R (T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
-{
-    typedef _mfi::cmf4<R, T, B1, B2, B3, B4> F;
-    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
-}
-
-// 5
-
-template<class R, class T,
-    class B1, class B2, class B3, class B4, class B5,
-    class A1, class A2, class A3, class A4, class A5, class A6>
-    _bi::bind_t<R, _mfi::mf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
-    BOOST_BIND(R (T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
-{
-    typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5> F;
-    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
-}
-
-template<class R, class T,
-    class B1, class B2, class B3, class B4, class B5,
-    class A1, class A2, class A3, class A4, class A5, class A6>
-    _bi::bind_t<R, _mfi::cmf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
-    BOOST_BIND(R (T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
-{
-    typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5> F;
-    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
-}
-
-// 6
-
-template<class R, class T,
-    class B1, class B2, class B3, class B4, class B5, class B6,
-    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    _bi::bind_t<R, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
-    BOOST_BIND(R (T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
-{
-    typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6> F;
-    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
-}
-
-template<class R, class T,
-    class B1, class B2, class B3, class B4, class B5, class B6,
-    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    _bi::bind_t<R, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
-    BOOST_BIND(R (T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
-{
-    typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6> F;
-    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
-}
-
-// 7
-
-template<class R, class T,
-    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
-    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    _bi::bind_t<R, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
-    BOOST_BIND(R (T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
-{
-    typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
-    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
-}
-
-template<class R, class T,
-    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
-    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    _bi::bind_t<R, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
-    BOOST_BIND(R (T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
-{
-    typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
-    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
-}
-
-// 8
-
-template<class R, class T,
-    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
-    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    _bi::bind_t<R, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
-    BOOST_BIND(R (T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
-{
-    typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
-    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
-}
-
-template<class R, class T,
-    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
-    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    _bi::bind_t<R, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
-    BOOST_BIND(R (T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
-{
-    typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
-    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
-    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
-}
-
-#endif // !defined(BOOST_MEM_FN_ENABLE_STDCALL)
+#endif
 
 } // namespace boost
 
diff --git a/include/boost/bind/bind_cc.hpp b/include/boost/bind/bind_cc.hpp
index f97dbaf..b733f57 100644
--- a/include/boost/bind/bind_cc.hpp
+++ b/include/boost/bind/bind_cc.hpp
@@ -1,7 +1,3 @@
-#ifndef BOOST_BIND_CC
-#error Do not include <boost/bind/bind_cc.hpp> directly.
-#endif
-
 //
 //  bind/bind_cc.hpp - support for different calling conventions
 //
@@ -18,28 +14,28 @@
 //
 
 template<class R>
-    _bi::bind_t<R, R (BOOST_BIND_CC *) (), _bi::list0>
-    BOOST_BIND(R (BOOST_BIND_CC *f) ())
+    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (), _bi::list0>
+    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) ())
 {
-    typedef R (BOOST_BIND_CC *F) ();
+    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) ();
     typedef _bi::list0 list_type;
     return _bi::bind_t<R, F, list_type> (f, list_type());
 }
 
 template<class R, class B1, class A1>
-    _bi::bind_t<R, R (BOOST_BIND_CC *) (B1), typename _bi::list_av_1<A1>::type>
-    BOOST_BIND(R (BOOST_BIND_CC *f) (B1), A1 a1)
+    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1), typename _bi::list_av_1<A1>::type>
+    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1), A1 a1)
 {
-    typedef R (BOOST_BIND_CC *F) (B1);
+    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1);
     typedef typename _bi::list_av_1<A1>::type list_type;
     return _bi::bind_t<R, F, list_type> (f, list_type(a1));
 }
 
 template<class R, class B1, class B2, class A1, class A2>
-    _bi::bind_t<R, R (BOOST_BIND_CC *) (B1, B2), typename _bi::list_av_2<A1, A2>::type>
-    BOOST_BIND(R (BOOST_BIND_CC *f) (B1, B2), A1 a1, A2 a2)
+    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2), typename _bi::list_av_2<A1, A2>::type>
+    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2), A1 a1, A2 a2)
 {
-    typedef R (BOOST_BIND_CC *F) (B1, B2);
+    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2);
     typedef typename _bi::list_av_2<A1, A2>::type list_type;
     return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
 }
@@ -47,10 +43,10 @@ template<class R, class B1, class B2, class A1, class A2>
 template<class R,
     class B1, class B2, class B3,
     class A1, class A2, class A3>
-    _bi::bind_t<R, R (BOOST_BIND_CC *) (B1, B2, B3), typename _bi::list_av_3<A1, A2, A3>::type>
-    BOOST_BIND(R (BOOST_BIND_CC *f) (B1, B2, B3), A1 a1, A2 a2, A3 a3)
+    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3), typename _bi::list_av_3<A1, A2, A3>::type>
+    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3), A1 a1, A2 a2, A3 a3)
 {
-    typedef R (BOOST_BIND_CC *F) (B1, B2, B3);
+    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3);
     typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
 }
@@ -58,10 +54,10 @@ template<class R,
 template<class R,
     class B1, class B2, class B3, class B4,
     class A1, class A2, class A3, class A4>
-    _bi::bind_t<R, R (BOOST_BIND_CC *) (B1, B2, B3, B4), typename _bi::list_av_4<A1, A2, A3, A4>::type>
-    BOOST_BIND(R (BOOST_BIND_CC *f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4)
+    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4), typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4)
 {
-    typedef R (BOOST_BIND_CC *F) (B1, B2, B3, B4);
+    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4);
     typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
 }
@@ -69,10 +65,10 @@ template<class R,
 template<class R,
     class B1, class B2, class B3, class B4, class B5,
     class A1, class A2, class A3, class A4, class A5>
-    _bi::bind_t<R, R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5), typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
-    BOOST_BIND(R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5), typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
-    typedef R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5);
+    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5);
     typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
 }
@@ -80,10 +76,10 @@ template<class R,
 template<class R,
     class B1, class B2, class B3, class B4, class B5, class B6,
     class A1, class A2, class A3, class A4, class A5, class A6>
-    _bi::bind_t<R, R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6), typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
-    BOOST_BIND(R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6), typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
-    typedef R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6);
+    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6);
     typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
 }
@@ -91,10 +87,10 @@ template<class R,
 template<class R,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    _bi::bind_t<R, R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7), typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
-    BOOST_BIND(R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7), typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
-    typedef R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7);
+    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7);
     typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
 }
@@ -102,10 +98,10 @@ template<class R,
 template<class R,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    _bi::bind_t<R, R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7, B8), typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
-    BOOST_BIND(R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7, B8), typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
-    typedef R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7, B8);
+    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7, B8);
     typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
 }
@@ -113,10 +109,10 @@ template<class R,
 template<class R,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8, class B9,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    _bi::bind_t<R, R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7, B8, B9), typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
-    BOOST_BIND(R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7, B8, B9), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7, B8, B9), typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7, B8, B9), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
-    typedef R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7, B8, B9);
+    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7, B8, B9);
     typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
 }
diff --git a/include/boost/bind/bind_mf_cc.hpp b/include/boost/bind/bind_mf_cc.hpp
index 5d6a343..f96b640 100644
--- a/include/boost/bind/bind_mf_cc.hpp
+++ b/include/boost/bind/bind_mf_cc.hpp
@@ -1,7 +1,3 @@
-#ifndef BOOST_BIND_MF_CC
-#error Do not include <boost/bind/bind_mf_cc.hpp> directly.
-#endif
-
 //
 //  bind/bind_mf_cc.hpp - support for different calling conventions
 //
@@ -21,20 +17,20 @@
 
 template<class R, class T,
     class A1>
-    _bi::bind_t<R, _mfi::mf0<R, T, R (BOOST_BIND_MF_CC T::*) ()>, typename _bi::list_av_1<A1>::type>
+    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf0)<R, T>, typename _bi::list_av_1<A1>::type>
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (), A1 a1)
 {
-    typedef _mfi::mf0<R, T, R (BOOST_BIND_MF_CC T::*) ()> F;
+    typedef _mfi::BOOST_BIND_MF_NAME(mf0)<R, T> F;
     typedef typename _bi::list_av_1<A1>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
 }
 
 template<class R, class T,
     class A1>
-    _bi::bind_t<R, _mfi::cmf0<R, T, R (BOOST_BIND_MF_CC T::*) () const>, typename _bi::list_av_1<A1>::type>
+    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf0)<R, T>, typename _bi::list_av_1<A1>::type>
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () const, A1 a1)
 {
-    typedef _mfi::cmf0<R, T, R (BOOST_BIND_MF_CC T::*) () const> F;
+    typedef _mfi::BOOST_BIND_MF_NAME(cmf0)<R, T> F;
     typedef typename _bi::list_av_1<A1>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
 }
@@ -44,10 +40,10 @@ template<class R, class T,
 template<class R, class T,
     class B1,
     class A1, class A2>
-    _bi::bind_t<R, _mfi::mf1<R, T, B1, R (BOOST_BIND_MF_CC T::*) (B1)>, typename _bi::list_av_2<A1, A2>::type>
+    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1), A1 a1, A2 a2)
 {
-    typedef _mfi::mf1<R, T, B1, R (BOOST_BIND_MF_CC T::*) (B1)> F;
+    typedef _mfi::BOOST_BIND_MF_NAME(mf1)<R, T, B1> F;
     typedef typename _bi::list_av_2<A1, A2>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
 }
@@ -55,10 +51,10 @@ template<class R, class T,
 template<class R, class T,
     class B1,
     class A1, class A2>
-    _bi::bind_t<R, _mfi::cmf1<R, T, B1, R (BOOST_BIND_MF_CC T::*) (B1) const>, typename _bi::list_av_2<A1, A2>::type>
+    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) const, A1 a1, A2 a2)
 {
-    typedef _mfi::cmf1<R, T, B1, R (BOOST_BIND_MF_CC T::*) (B1) const> F;
+    typedef _mfi::BOOST_BIND_MF_NAME(cmf1)<R, T, B1> F;
     typedef typename _bi::list_av_2<A1, A2>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
 }
@@ -68,10 +64,10 @@ template<class R, class T,
 template<class R, class T,
     class B1, class B2,
     class A1, class A2, class A3>
-    _bi::bind_t<R, _mfi::mf2<R, T, B1, B2, R (BOOST_BIND_MF_CC T::*) (B1, B2)>, typename _bi::list_av_3<A1, A2, A3>::type>
+    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
 {
-    typedef _mfi::mf2<R, T, B1, B2, R (BOOST_BIND_MF_CC T::*) (B1, B2)> F;
+    typedef _mfi::BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2> F;
     typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
 }
@@ -79,10 +75,10 @@ template<class R, class T,
 template<class R, class T,
     class B1, class B2,
     class A1, class A2, class A3>
-    _bi::bind_t<R, _mfi::cmf2<R, T, B1, B2, R (BOOST_BIND_MF_CC T::*) (B1, B2) const>, typename _bi::list_av_3<A1, A2, A3>::type>
+    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
 {
-    typedef _mfi::cmf2<R, T, B1, B2, R (BOOST_BIND_MF_CC T::*) (B1, B2) const> F;
+    typedef _mfi::BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2> F;
     typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
 }
@@ -92,10 +88,10 @@ template<class R, class T,
 template<class R, class T,
     class B1, class B2, class B3,
     class A1, class A2, class A3, class A4>
-    _bi::bind_t<R, _mfi::mf3<R, T, B1, B2, B3, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3)>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
 {
-    typedef _mfi::mf3<R, T, B1, B2, B3, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3)> F;
+    typedef _mfi::BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3> F;
     typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
 }
@@ -103,10 +99,10 @@ template<class R, class T,
 template<class R, class T,
     class B1, class B2, class B3,
     class A1, class A2, class A3, class A4>
-    _bi::bind_t<R, _mfi::cmf3<R, T, B1, B2, B3, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3) const>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
 {
-    typedef _mfi::cmf3<R, T, B1, B2, B3, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3) const> F;
+    typedef _mfi::BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3> F;
     typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
 }
@@ -116,10 +112,10 @@ template<class R, class T,
 template<class R, class T,
     class B1, class B2, class B3, class B4,
     class A1, class A2, class A3, class A4, class A5>
-    _bi::bind_t<R, _mfi::mf4<R, T, B1, B2, B3, B4, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3, B4)>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
-    typedef _mfi::mf4<R, T, B1, B2, B3, B4, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3, B4)> F;
+    typedef _mfi::BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4> F;
     typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
 }
@@ -127,10 +123,10 @@ template<class R, class T,
 template<class R, class T,
     class B1, class B2, class B3, class B4,
     class A1, class A2, class A3, class A4, class A5>
-    _bi::bind_t<R, _mfi::cmf4<R, T, B1, B2, B3, B4, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3, B4) const>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
-    typedef _mfi::cmf4<R, T, B1, B2, B3, B4, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3, B4) const> F;
+    typedef _mfi::BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4> F;
     typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
 }
@@ -140,10 +136,10 @@ template<class R, class T,
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5,
     class A1, class A2, class A3, class A4, class A5, class A6>
-    _bi::bind_t<R, _mfi::mf5<R, T, B1, B2, B3, B4, B5, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3, B4, B5)>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
-    typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3, B4, B5)> F;
+    typedef _mfi::BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5> F;
     typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
 }
@@ -151,10 +147,10 @@ template<class R, class T,
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5,
     class A1, class A2, class A3, class A4, class A5, class A6>
-    _bi::bind_t<R, _mfi::cmf5<R, T, B1, B2, B3, B4, B5, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3, B4, B5) const>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
-    typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3, B4, B5) const> F;
+    typedef _mfi::BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5> F;
     typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
 }
@@ -164,10 +160,10 @@ template<class R, class T,
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    _bi::bind_t<R, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3, B4, B5, B6)>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
-    typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3, B4, B5, B6)> F;
+    typedef _mfi::BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6> F;
     typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
 }
@@ -175,10 +171,10 @@ template<class R, class T,
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    _bi::bind_t<R, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3, B4, B5, B6) const>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
-    typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3, B4, B5, B6) const> F;
+    typedef _mfi::BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6> F;
     typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
 }
@@ -188,10 +184,10 @@ template<class R, class T,
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    _bi::bind_t<R, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3, B4, B5, B6, B7)>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
-    typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3, B4, B5, B6, B7)> F;
+    typedef _mfi::BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
     typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
 }
@@ -199,10 +195,10 @@ template<class R, class T,
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    _bi::bind_t<R, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3, B4, B5, B6, B7) const>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
-    typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3, B4, B5, B6, B7) const> F;
+    typedef _mfi::BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
     typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
 }
@@ -212,10 +208,10 @@ template<class R, class T,
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    _bi::bind_t<R, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3, B4, B5, B6, B7, B8)>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
-    typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3, B4, B5, B6, B7, B8)> F;
+    typedef _mfi::BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
     typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
 }
@@ -223,10 +219,10 @@ template<class R, class T,
 template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    _bi::bind_t<R, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3, B4, B5, B6, B7, B8) const>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
     BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
-    typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8, R (BOOST_BIND_MF_CC T::*) (B1, B2, B3, B4, B5, B6, B7, B8) const> F;
+    typedef _mfi::BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
     typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
     return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
 }
diff --git a/include/boost/bind/mem_fn_cc.hpp b/include/boost/bind/mem_fn_cc.hpp
index 91459f0..a89a2ee 100644
--- a/include/boost/bind/mem_fn_cc.hpp
+++ b/include/boost/bind/mem_fn_cc.hpp
@@ -1,7 +1,3 @@
-#ifndef BOOST_MEM_FN_CC
-#error Do not include <boost/bind/mem_fn_cc.hpp> directly.
-#endif
-
 //
 //  bind/mem_fn_cc.hpp - support for different calling conventions
 //
@@ -17,92 +13,92 @@
 //  See http://www.boost.org/libs/bind/mem_fn.html for documentation.
 //
 
-template<class R, class T> _mfi::mf0<R, T, R (BOOST_MEM_FN_CC T::*) ()> mem_fn(R (BOOST_MEM_FN_CC T::*f) ())
+template<class R, class T> _mfi::BOOST_MEM_FN_NAME(mf0)<R, T> mem_fn(R (BOOST_MEM_FN_CC T::*f) ())
 {
-    return _mfi::mf0<R, T, R (BOOST_MEM_FN_CC T::*) ()>(f);
+    return _mfi::BOOST_MEM_FN_NAME(mf0)<R, T>(f);
 }
 
-template<class R, class T> _mfi::cmf0<R, T, R (BOOST_MEM_FN_CC T::*) () const> mem_fn(R (BOOST_MEM_FN_CC T::*f) () const)
+template<class R, class T> _mfi::BOOST_MEM_FN_NAME(cmf0)<R, T> mem_fn(R (BOOST_MEM_FN_CC T::*f) () const)
 {
-    return _mfi::cmf0<R, T, R (BOOST_MEM_FN_CC T::*) () const>(f);
+    return _mfi::BOOST_MEM_FN_NAME(cmf0)<R, T>(f);
 }
 
-template<class R, class T, class A1> _mfi::mf1<R, T, A1, R (BOOST_MEM_FN_CC T::*) (A1)> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1))
+template<class R, class T, class A1> _mfi::BOOST_MEM_FN_NAME(mf1)<R, T, A1> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1))
 {
-    return _mfi::mf1<R, T, A1, R (BOOST_MEM_FN_CC T::*) (A1)>(f);
+    return _mfi::BOOST_MEM_FN_NAME(mf1)<R, T, A1>(f);
 }
 
-template<class R, class T, class A1> _mfi::cmf1<R, T, A1, R (BOOST_MEM_FN_CC T::*) (A1) const> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1) const)
+template<class R, class T, class A1> _mfi::BOOST_MEM_FN_NAME(cmf1)<R, T, A1> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1) const)
 {
-    return _mfi::cmf1<R, T, A1, R (BOOST_MEM_FN_CC T::*) (A1) const>(f);
+    return _mfi::BOOST_MEM_FN_NAME(cmf1)<R, T, A1>(f);
 }
 
-template<class R, class T, class A1, class A2> _mfi::mf2<R, T, A1, A2, R (BOOST_MEM_FN_CC T::*) (A1, A2)> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2))
+template<class R, class T, class A1, class A2> _mfi::BOOST_MEM_FN_NAME(mf2)<R, T, A1, A2> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2))
 {
-    return _mfi::mf2<R, T, A1, A2, R (BOOST_MEM_FN_CC T::*) (A1, A2)>(f);
+    return _mfi::BOOST_MEM_FN_NAME(mf2)<R, T, A1, A2>(f);
 }
 
-template<class R, class T, class A1, class A2> _mfi::cmf2<R, T, A1, A2, R (BOOST_MEM_FN_CC T::*) (A1, A2) const> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2) const)
+template<class R, class T, class A1, class A2> _mfi::BOOST_MEM_FN_NAME(cmf2)<R, T, A1, A2> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2) const)
 {
-    return _mfi::cmf2<R, T, A1, A2, R (BOOST_MEM_FN_CC T::*) (A1, A2) const>(f);
+    return _mfi::BOOST_MEM_FN_NAME(cmf2)<R, T, A1, A2>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3> _mfi::mf3<R, T, A1, A2, A3, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3)> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3))
+template<class R, class T, class A1, class A2, class A3> _mfi::BOOST_MEM_FN_NAME(mf3)<R, T, A1, A2, A3> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3))
 {
-    return _mfi::mf3<R, T, A1, A2, A3, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3)>(f);
+    return _mfi::BOOST_MEM_FN_NAME(mf3)<R, T, A1, A2, A3>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3> _mfi::cmf3<R, T, A1, A2, A3, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3) const> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3) const)
+template<class R, class T, class A1, class A2, class A3> _mfi::BOOST_MEM_FN_NAME(cmf3)<R, T, A1, A2, A3> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3) const)
 {
-    return _mfi::cmf3<R, T, A1, A2, A3, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3) const>(f);
+    return _mfi::BOOST_MEM_FN_NAME(cmf3)<R, T, A1, A2, A3>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3, class A4> _mfi::mf4<R, T, A1, A2, A3, A4, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4)> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4))
+template<class R, class T, class A1, class A2, class A3, class A4> _mfi::BOOST_MEM_FN_NAME(mf4)<R, T, A1, A2, A3, A4> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4))
 {
-    return _mfi::mf4<R, T, A1, A2, A3, A4, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4)>(f);
+    return _mfi::BOOST_MEM_FN_NAME(mf4)<R, T, A1, A2, A3, A4>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3, class A4> _mfi::cmf4<R, T, A1, A2, A3, A4, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4) const> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4) const)
+template<class R, class T, class A1, class A2, class A3, class A4> _mfi::BOOST_MEM_FN_NAME(cmf4)<R, T, A1, A2, A3, A4> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4) const)
 {
-    return _mfi::cmf4<R, T, A1, A2, A3, A4, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4) const>(f);
+    return _mfi::BOOST_MEM_FN_NAME(cmf4)<R, T, A1, A2, A3, A4>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::mf5<R, T, A1, A2, A3, A4, A5, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5)> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5))
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::BOOST_MEM_FN_NAME(mf5)<R, T, A1, A2, A3, A4, A5> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5))
 {
-    return _mfi::mf5<R, T, A1, A2, A3, A4, A5, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5)>(f);
+    return _mfi::BOOST_MEM_FN_NAME(mf5)<R, T, A1, A2, A3, A4, A5>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::cmf5<R, T, A1, A2, A3, A4, A5, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5) const> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5) const)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::BOOST_MEM_FN_NAME(cmf5)<R, T, A1, A2, A3, A4, A5> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5) const)
 {
-    return _mfi::cmf5<R, T, A1, A2, A3, A4, A5, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5) const>(f);
+    return _mfi::BOOST_MEM_FN_NAME(cmf5)<R, T, A1, A2, A3, A4, A5>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6)> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6))
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::BOOST_MEM_FN_NAME(mf6)<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6))
 {
-    return _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6)>(f);
+    return _mfi::BOOST_MEM_FN_NAME(mf6)<R, T, A1, A2, A3, A4, A5, A6>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6) const> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6) const)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::BOOST_MEM_FN_NAME(cmf6)<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6) const)
 {
-    return _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6) const>(f);
+    return _mfi::BOOST_MEM_FN_NAME(cmf6)<R, T, A1, A2, A3, A4, A5, A6>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7)> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7))
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::BOOST_MEM_FN_NAME(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7))
 {
-    return _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7)>(f);
+    return _mfi::BOOST_MEM_FN_NAME(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7) const> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7) const)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::BOOST_MEM_FN_NAME(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7) const)
 {
-    return _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7) const>(f);
+    return _mfi::BOOST_MEM_FN_NAME(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7, A8)> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7, A8))
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::BOOST_MEM_FN_NAME(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7, A8))
 {
-    return _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7, A8)>(f);
+    return _mfi::BOOST_MEM_FN_NAME(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
 }
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7, A8) const> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7, A8) const)
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::BOOST_MEM_FN_NAME(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R (BOOST_MEM_FN_CC T::*f) (A1, A2, A3, A4, A5, A6, A7, A8) const)
 {
-    return _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8, R (BOOST_MEM_FN_CC T::*) (A1, A2, A3, A4, A5, A6, A7, A8) const>(f);
+    return _mfi::BOOST_MEM_FN_NAME(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
 }
diff --git a/include/boost/bind/mem_fn_template.hpp b/include/boost/bind/mem_fn_template.hpp
new file mode 100644
index 0000000..1daa0c8
--- /dev/null
+++ b/include/boost/bind/mem_fn_template.hpp
@@ -0,0 +1,575 @@
+//
+//  bind/mem_fn_template.hpp
+//
+//  Do not include this header directly
+//
+//  Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
+//
+//  Permission to copy, use, modify, sell and distribute this software
+//  is granted provided this copyright notice appears in all copies.
+//  This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+//
+//  See http://www.boost.org/libs/bind/mem_fn.html for documentation.
+//
+
+// mf0
+
+template<class R, class T> class BOOST_MEM_FN_NAME(mf0)
+{
+public:
+
+    typedef R result_type;
+    typedef T * first_argument_type;
+
+private:
+    
+    typedef R (BOOST_MEM_FN_CC T::*F) ();
+    F f_;
+
+public:
+    
+    explicit BOOST_MEM_FN_NAME(mf0)(F f): f_(f) {}
+
+    R operator()(T * p) const
+    {
+        BOOST_MEM_FN_RETURN (p->*f_)();
+    }
+
+    template<class U> R operator()(U & u) const
+    {
+        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
+    }
+
+    R operator()(T & t) const
+    {
+        BOOST_MEM_FN_RETURN (t.*f_)();
+    }
+};
+
+// cmf0
+
+template<class R, class T> class BOOST_MEM_FN_NAME(cmf0)
+{
+public:
+
+    typedef R result_type;
+    typedef T const * first_argument_type;
+
+private:
+    
+    typedef R (BOOST_MEM_FN_CC T::*F) () const;
+    F f_;
+
+public:
+    
+    explicit BOOST_MEM_FN_NAME(cmf0)(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u) const
+    {
+        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)();
+    }
+
+    R operator()(T const & t) const
+    {
+        BOOST_MEM_FN_RETURN (t.*f_)();
+    }
+};
+
+// mf1
+
+template<class R, class T, class A1> class BOOST_MEM_FN_NAME(mf1)
+{
+public:
+
+    typedef R result_type;
+    typedef T * first_argument_type;
+    typedef A1 second_argument_type;
+
+private:
+    
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1);
+    F f_;
+
+public:
+    
+    explicit BOOST_MEM_FN_NAME(mf1)(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1) const
+    {
+        BOOST_MEM_FN_RETURN (p->*f_)(a1);
+    }
+
+    template<class U> R operator()(U & u, A1 a1) const
+    {
+        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(a1);
+    }
+
+    R operator()(T & t, A1 a1) const
+    {
+        BOOST_MEM_FN_RETURN (t.*f_)(a1);
+    }
+};
+
+// cmf1
+
+template<class R, class T, class A1> class BOOST_MEM_FN_NAME(cmf1)
+{
+public:
+
+    typedef R result_type;
+    typedef T const * first_argument_type;
+    typedef A1 second_argument_type;
+
+private:
+    
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1) const;
+    F f_;
+
+public:
+    
+    explicit BOOST_MEM_FN_NAME(cmf1)(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1) const
+    {
+        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(a1);
+    }
+
+    R operator()(T const & t, A1 a1) const
+    {
+        BOOST_MEM_FN_RETURN (t.*f_)(a1);
+    }
+};
+
+// mf2
+
+template<class R, class T, class A1, class A2> class BOOST_MEM_FN_NAME(mf2)
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2);
+    F f_;
+
+public:
+    
+    explicit BOOST_MEM_FN_NAME(mf2)(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2) const
+    {
+        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2) const
+    {
+        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(a1, a2);
+    }
+
+    R operator()(T & t, A1 a1, A2 a2) const
+    {
+        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
+    }
+};
+
+// cmf2
+
+template<class R, class T, class A1, class A2> class BOOST_MEM_FN_NAME(cmf2)
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2) const;
+    F f_;
+
+public:
+    
+    explicit BOOST_MEM_FN_NAME(cmf2)(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2) const
+    {
+        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(a1, a2);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2) const
+    {
+        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2);
+    }
+};
+
+// mf3
+
+template<class R, class T, class A1, class A2, class A3> class BOOST_MEM_FN_NAME(mf3)
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3);
+    F f_;
+
+public:
+    
+    explicit BOOST_MEM_FN_NAME(mf3)(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3) const
+    {
+        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3) const
+    {
+        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(a1, a2, a3);
+    }
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3) const
+    {
+        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
+    }
+};
+
+// cmf3
+
+template<class R, class T, class A1, class A2, class A3> class BOOST_MEM_FN_NAME(cmf3)
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3) const;
+    F f_;
+
+public:
+
+    explicit BOOST_MEM_FN_NAME(cmf3)(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
+    {
+        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(a1, a2, a3);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3) const
+    {
+        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3);
+    }
+};
+
+// mf4
+
+template<class R, class T, class A1, class A2, class A3, class A4> class BOOST_MEM_FN_NAME(mf4)
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4);
+    F f_;
+
+public:
+    
+    explicit BOOST_MEM_FN_NAME(mf4)(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(a1, a2, a3, a4);
+    }
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
+    }
+};
+
+// cmf4
+
+template<class R, class T, class A1, class A2, class A3, class A4> class BOOST_MEM_FN_NAME(cmf4)
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4) const;
+    F f_;
+
+public:
+    
+    explicit BOOST_MEM_FN_NAME(cmf4)(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(a1, a2, a3, a4);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4);
+    }
+};
+
+// mf5
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> class BOOST_MEM_FN_NAME(mf5)
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5);
+    F f_;
+
+public:
+    
+    explicit BOOST_MEM_FN_NAME(mf5)(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(a1, a2, a3, a4, a5);
+    }
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
+    }
+};
+
+// cmf5
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> class BOOST_MEM_FN_NAME(cmf5)
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5) const;
+    F f_;
+
+public:
+    
+    explicit BOOST_MEM_FN_NAME(cmf5)(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(a1, a2, a3, a4, a5);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5);
+    }
+};
+
+// mf6
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> class BOOST_MEM_FN_NAME(mf6)
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6);
+    F f_;
+
+public:
+
+    explicit BOOST_MEM_FN_NAME(mf6)(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6);
+    }
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
+    }
+};
+
+// cmf6
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> class BOOST_MEM_FN_NAME(cmf6)
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6) const;
+    F f_;
+
+public:
+    
+    explicit BOOST_MEM_FN_NAME(cmf6)(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6);
+    }
+};
+
+// mf7
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> class BOOST_MEM_FN_NAME(mf7)
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7);
+    F f_;
+
+public:
+    
+    explicit BOOST_MEM_FN_NAME(mf7)(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6, a7);
+    }
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
+    }
+};
+
+// cmf7
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> class BOOST_MEM_FN_NAME(cmf7)
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7) const;
+    F f_;
+
+public:
+    
+    explicit BOOST_MEM_FN_NAME(cmf7)(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6, a7);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
+    }
+};
+
+// mf8
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> class BOOST_MEM_FN_NAME(mf8)
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8);
+    F f_;
+
+public:
+    
+    explicit BOOST_MEM_FN_NAME(mf8)(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+};
+
+// cmf8
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> class BOOST_MEM_FN_NAME(cmf8)
+{
+public:
+
+    typedef R result_type;
+
+private:
+    
+    typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const;
+    F f_;
+
+public:
+    
+    explicit BOOST_MEM_FN_NAME(cmf8)(F f): f_(f) {}
+
+    R operator()(T const * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        BOOST_MEM_FN_RETURN (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        BOOST_MEM_FN_RETURN (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        BOOST_MEM_FN_RETURN (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+};
+
diff --git a/include/boost/bind/mem_fn_vw.hpp b/include/boost/bind/mem_fn_vw.hpp
new file mode 100644
index 0000000..f050127
--- /dev/null
+++ b/include/boost/bind/mem_fn_vw.hpp
@@ -0,0 +1,132 @@
+//
+//  bind/mem_fn_vw.hpp - void return helper wrappers
+//
+//  Do not include this header directly
+//
+//  Copyright (c) 2001 Peter Dimov and Multi Media Ltd.
+//
+//  Permission to copy, use, modify, sell and distribute this software
+//  is granted provided this copyright notice appears in all copies.
+//  This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+//
+//  See http://www.boost.org/libs/bind/mem_fn.html for documentation.
+//
+
+template<class R, class T> struct BOOST_MEM_FN_NAME(mf0): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf0)<R, T>
+{
+	typedef R (BOOST_MEM_FN_CC T::*F) ();
+	explicit BOOST_MEM_FN_NAME(mf0)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf0)<R, T>(f) {}
+};
+
+template<class R, class T> struct BOOST_MEM_FN_NAME(cmf0): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf0)<R, T>
+{
+	typedef R (BOOST_MEM_FN_CC T::*F) () const;
+	explicit BOOST_MEM_FN_NAME(cmf0)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf0)<R, T>(f) {}
+};
+
+
+template<class R, class T, class A1> struct BOOST_MEM_FN_NAME(mf1): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf1)<R, T, A1>
+{
+	typedef R (BOOST_MEM_FN_CC T::*F) (A1);
+	explicit BOOST_MEM_FN_NAME(mf1)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf1)<R, T, A1>(f) {}
+};
+
+template<class R, class T, class A1> struct BOOST_MEM_FN_NAME(cmf1): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf1)<R, T, A1>
+{
+	typedef R (BOOST_MEM_FN_CC T::*F) (A1) const;
+	explicit BOOST_MEM_FN_NAME(cmf1)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf1)<R, T, A1>(f) {}
+};
+
+
+template<class R, class T, class A1, class A2> struct BOOST_MEM_FN_NAME(mf2): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf2)<R, T, A1, A2>
+{
+	typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2);
+	explicit BOOST_MEM_FN_NAME(mf2)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf2)<R, T, A1, A2>(f) {}
+};
+
+template<class R, class T, class A1, class A2> struct BOOST_MEM_FN_NAME(cmf2): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf2)<R, T, A1, A2>
+{
+	typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2) const;
+	explicit BOOST_MEM_FN_NAME(cmf2)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf2)<R, T, A1, A2>(f) {}
+};
+
+
+template<class R, class T, class A1, class A2, class A3> struct BOOST_MEM_FN_NAME(mf3): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf3)<R, T, A1, A2, A3>
+{
+	typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3);
+	explicit BOOST_MEM_FN_NAME(mf3)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf3)<R, T, A1, A2, A3>(f) {}
+};
+
+template<class R, class T, class A1, class A2, class A3> struct BOOST_MEM_FN_NAME(cmf3): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf3)<R, T, A1, A2, A3>
+{
+	typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3) const;
+	explicit BOOST_MEM_FN_NAME(cmf3)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf3)<R, T, A1, A2, A3>(f) {}
+};
+
+
+template<class R, class T, class A1, class A2, class A3, class A4> struct BOOST_MEM_FN_NAME(mf4): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf4)<R, T, A1, A2, A3, A4>
+{
+	typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4);
+	explicit BOOST_MEM_FN_NAME(mf4)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf4)<R, T, A1, A2, A3, A4>(f) {}
+};
+
+template<class R, class T, class A1, class A2, class A3, class A4> struct BOOST_MEM_FN_NAME(cmf4): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf4)<R, T, A1, A2, A3, A4>
+{
+	typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4) const;
+	explicit BOOST_MEM_FN_NAME(cmf4)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf4)<R, T, A1, A2, A3, A4>(f) {}
+};
+
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> struct BOOST_MEM_FN_NAME(mf5): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf5)<R, T, A1, A2, A3, A4, A5>
+{
+	typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5);
+	explicit BOOST_MEM_FN_NAME(mf5)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf5)<R, T, A1, A2, A3, A4, A5>(f) {}
+};
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> struct BOOST_MEM_FN_NAME(cmf5): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf5)<R, T, A1, A2, A3, A4, A5>
+{
+	typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5) const;
+	explicit BOOST_MEM_FN_NAME(cmf5)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf5)<R, T, A1, A2, A3, A4, A5>(f) {}
+};
+
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> struct BOOST_MEM_FN_NAME(mf6): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf6)<R, T, A1, A2, A3, A4, A5, A6>
+{
+	typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6);
+	explicit BOOST_MEM_FN_NAME(mf6)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf6)<R, T, A1, A2, A3, A4, A5, A6>(f) {}
+};
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> struct BOOST_MEM_FN_NAME(cmf6): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf6)<R, T, A1, A2, A3, A4, A5, A6>
+{
+	typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6) const;
+	explicit BOOST_MEM_FN_NAME(cmf6)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf6)<R, T, A1, A2, A3, A4, A5, A6>(f) {}
+};
+
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct BOOST_MEM_FN_NAME(mf7): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7>
+{
+	typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7);
+	explicit BOOST_MEM_FN_NAME(mf7)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf7)<R, T, A1, A2, A3, A4, A5, A6, A7>(f) {}
+};
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct BOOST_MEM_FN_NAME(cmf7): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7>
+{
+	typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7) const;
+	explicit BOOST_MEM_FN_NAME(cmf7)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf7)<R, T, A1, A2, A3, A4, A5, A6, A7>(f) {}
+};
+
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct BOOST_MEM_FN_NAME(mf8): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8>
+{
+	typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8);
+	explicit BOOST_MEM_FN_NAME(mf8)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(mf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f) {}
+};
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct BOOST_MEM_FN_NAME(cmf8): public mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8>
+{
+	typedef R (BOOST_MEM_FN_CC T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const;
+	explicit BOOST_MEM_FN_NAME(cmf8)(F f): mf<R>::BOOST_NESTED_TEMPLATE BOOST_MEM_FN_NAME2(cmf8)<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f) {}
+};
+
+
diff --git a/include/boost/mem_fn.hpp b/include/boost/mem_fn.hpp
index 41488a4..a930dca 100644
--- a/include/boost/mem_fn.hpp
+++ b/include/boost/mem_fn.hpp
@@ -41,1370 +41,147 @@ template<class T> T * get_pointer(shared_ptr<T> const & p)
     return p.get();
 }
 
-//
+#ifdef BOOST_NO_VOID_RETURNS
+
 namespace _mfi // mem_fun_impl
 {
 
-template <class R>
-struct mf
+template<class V> struct mf
 {
-    
-// mf0_
 
-    template<class T, class F> class mf0_
-    {
-     public:
+#define BOOST_MEM_FN_RETURN return
 
-        typedef R result_type;
-        typedef T * first_argument_type;
+#define BOOST_MEM_FN_NAME(X) inner_##X
+#define BOOST_MEM_FN_CC
 
-     private:
-    
-        F f_;
+#include <boost/bind/mem_fn_template.hpp>
 
-     public:
-    
-        explicit mf0_(F f): f_(f) {}
+#undef BOOST_MEM_FN_CC
+#undef BOOST_MEM_FN_NAME
 
-        R operator()(T * p) const
-        {
-            return (p->*f_)();
-        }
+#ifdef BOOST_MEM_FN_ENABLE_STDCALL
 
-        template<class U> R operator()(U & u) const
-        {
-            return (get_pointer(u)->*f_)();
-        }
+#define BOOST_MEM_FN_NAME(X) inner_##X##_stdcall
+#define BOOST_MEM_FN_CC __stdcall
 
-        R operator()(T & t) const
-        {
-            return (t.*f_)();
-        }
-    };
+#include <boost/bind/mem_fn_template.hpp>
 
-// cmf0_
+#undef BOOST_MEM_FN_CC
+#undef BOOST_MEM_FN_NAME
 
-    template<class T, class F> class cmf0_
-    {
-     public:
-
-        typedef R result_type;
-        typedef T const * first_argument_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit cmf0_(F f): f_(f) {}
-
-        template<class U> R operator()(U const & u) const
-        {
-            return (get_pointer(u)->*f_)();
-        }
-
-        R operator()(T const & t) const
-        {
-            return (t.*f_)();
-        }
-    };
-
-// mf1_
-
-    template<class T, class A1, class F> class mf1_
-    {
-     public:
-
-        typedef R result_type;
-        typedef T * first_argument_type;
-        typedef A1 second_argument_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit mf1_(F f): f_(f) {}
-
-        R operator()(T * p, A1 a1) const
-        {
-            return (p->*f_)(a1);
-        }
-
-        template<class U> R operator()(U & u, A1 a1) const
-        {
-            return (get_pointer(u)->*f_)(a1);
-        }
-
-        R operator()(T & t, A1 a1) const
-        {
-            return (t.*f_)(a1);
-        }
-    };
-
-// cmf1_
-
-    template<class T, class A1, class F> class cmf1_
-    {
-     public:
-
-        typedef R result_type;
-        typedef T const * first_argument_type;
-        typedef A1 second_argument_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit cmf1_(F f): f_(f) {}
-
-        template<class U> R operator()(U const & u, A1 a1) const
-        {
-            return (get_pointer(u)->*f_)(a1);
-        }
-
-        R operator()(T const & t, A1 a1) const
-        {
-            return (t.*f_)(a1);
-        }
-    };
-
-// mf2_
-
-    template<class T, class A1, class A2, class F> class mf2_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit mf2_(F f): f_(f) {}
-
-        R operator()(T * p, A1 a1, A2 a2) const
-        {
-            return (p->*f_)(a1, a2);
-        }
-
-        template<class U> R operator()(U & u, A1 a1, A2 a2) const
-        {
-            return (get_pointer(u)->*f_)(a1, a2);
-        }
-
-        R operator()(T & t, A1 a1, A2 a2) const
-        {
-            return (t.*f_)(a1, a2);
-        }
-    };
-
-// cmf2_
-
-    template<class T, class A1, class A2, class F> class cmf2_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit cmf2_(F f): f_(f) {}
-
-        template<class U> R operator()(U const & u, A1 a1, A2 a2) const
-        {
-            return (get_pointer(u)->*f_)(a1, a2);
-        }
-
-        R operator()(T const & t, A1 a1, A2 a2) const
-        {
-            return (t.*f_)(a1, a2);
-        }
-    };
-
-// mf3_
-
-    template<class T, class A1, class A2, class A3, class F> class mf3_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit mf3_(F f): f_(f) {}
-
-        R operator()(T * p, A1 a1, A2 a2, A3 a3) const
-        {
-            return (p->*f_)(a1, a2, a3);
-        }
-
-        template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3) const
-        {
-            return (get_pointer(u)->*f_)(a1, a2, a3);
-        }
-
-        R operator()(T & t, A1 a1, A2 a2, A3 a3) const
-        {
-            return (t.*f_)(a1, a2, a3);
-        }
-    };
-
-// cmf3_
-
-    template<class T, class A1, class A2, class A3, class F> class cmf3_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-
-        F f_;
-
-     public:
-
-        explicit cmf3_(F f): f_(f) {}
-
-        template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
-        {
-            return (get_pointer(u)->*f_)(a1, a2, a3);
-        }
-
-        R operator()(T const & t, A1 a1, A2 a2, A3 a3) const
-        {
-            return (t.*f_)(a1, a2, a3);
-        }
-    };
-
-// mf4_
-
-    template<class T, class A1, class A2, class A3, class A4, class F> class mf4_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit mf4_(F f): f_(f) {}
-
-        R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4) const
-        {
-            return (p->*f_)(a1, a2, a3, a4);
-        }
-
-        template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4) const
-        {
-            return (get_pointer(u)->*f_)(a1, a2, a3, a4);
-        }
-
-        R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4) const
-        {
-            return (t.*f_)(a1, a2, a3, a4);
-        }
-    };
-
-// cmf4_
-
-    template<class T, class A1, class A2, class A3, class A4, class F> class cmf4_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit cmf4_(F f): f_(f) {}
-
-        template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
-        {
-            return (get_pointer(u)->*f_)(a1, a2, a3, a4);
-        }
-
-        R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4) const
-        {
-            return (t.*f_)(a1, a2, a3, a4);
-        }
-    };
-
-// mf5_
-
-    template<class T, class A1, class A2, class A3, class A4, class A5, class F> class mf5_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit mf5_(F f): f_(f) {}
-
-        R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
-        {
-            return (p->*f_)(a1, a2, a3, a4, a5);
-        }
-
-        template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
-        {
-            return (get_pointer(u)->*f_)(a1, a2, a3, a4, a5);
-        }
-
-        R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
-        {
-            return (t.*f_)(a1, a2, a3, a4, a5);
-        }
-    };
-
-// cmf5_
-
-    template<class T, class A1, class A2, class A3, class A4, class A5, class F> class cmf5_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit cmf5_(F f): f_(f) {}
-
-        template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
-        {
-            return (get_pointer(u)->*f_)(a1, a2, a3, a4, a5);
-        }
-
-        R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
-        {
-            return (t.*f_)(a1, a2, a3, a4, a5);
-        }
-    };
-
-// mf6_
-
-    template<class T, class A1, class A2, class A3, class A4, class A5, class A6, class F> class mf6_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-
-        F f_;
-
-     public:
-
-        explicit mf6_(F f): f_(f) {}
-
-        R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
-        {
-            return (p->*f_)(a1, a2, a3, a4, a5, a6);
-        }
-
-        template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
-        {
-            return (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6);
-        }
-
-        R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
-        {
-            return (t.*f_)(a1, a2, a3, a4, a5, a6);
-        }
-    };
-
-// cmf6_
-
-    template<class T, class A1, class A2, class A3, class A4, class A5, class A6, class F> class cmf6_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit cmf6_(F f): f_(f) {}
-
-        template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
-        {
-            return (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6);
-        }
-
-        R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
-        {
-            return (t.*f_)(a1, a2, a3, a4, a5, a6);
-        }
-    };
-
-// mf7_
-
-    template<class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class F> class mf7_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit mf7_(F f): f_(f) {}
-
-        R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
-        {
-            return (p->*f_)(a1, a2, a3, a4, a5, a6, a7);
-        }
-
-        template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
-        {
-            return (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6, a7);
-        }
-
-        R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
-        {
-            return (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
-        }
-    };
-
-// cmf7_
-
-    template<class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class F> class cmf7_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit cmf7_(F f): f_(f) {}
-
-        template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
-        {
-            return (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6, a7);
-        }
-
-        R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
-        {
-            return (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
-        }
-    };
-
-// mf8_
-
-    template<class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class F> class mf8_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit mf8_(F f): f_(f) {}
-
-        R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
-        {
-            return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
-        }
-
-        template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
-        {
-            return (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
-        }
-
-        R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
-        {
-            return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
-        }
-    };
-
-// cmf8_
-
-    template<class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class F> class cmf8_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit cmf8_(F f): f_(f) {}
-
-        R operator()(T const * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
-        {
-            return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
-        }
-
-        template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
-        {
-            return (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
-        }
-
-        R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
-        {
-            return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
-        }
-    };
-
-};
-
-template <>
-struct mf<void>
-{
-    typedef void R;
-    
-// mf0_
-
-    template<class T, class F> class mf0_
-    {
-     public:
-
-        typedef R result_type;
-        typedef T * first_argument_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit mf0_(F f): f_(f) {}
-
-        R operator()(T * p) const
-        {
-            (p->*f_)();
-        }
-
-        template<class U> R operator()(U & u) const
-        {
-            (get_pointer(u)->*f_)();
-        }
-
-        R operator()(T & t) const
-        {
-            (t.*f_)();
-        }
-    };
-
-// cmf0_
-
-    template<class T, class F> class cmf0_
-    {
-     public:
-
-        typedef R result_type;
-        typedef T const * first_argument_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit cmf0_(F f): f_(f) {}
-
-        template<class U> R operator()(U const & u) const
-        {
-            (get_pointer(u)->*f_)();
-        }
-
-        R operator()(T const & t) const
-        {
-            (t.*f_)();
-        }
-    };
-
-// mf1_
-
-    template<class T, class A1, class F> class mf1_
-    {
-     public:
-
-        typedef R result_type;
-        typedef T * first_argument_type;
-        typedef A1 second_argument_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit mf1_(F f): f_(f) {}
-
-        R operator()(T * p, A1 a1) const
-        {
-            (p->*f_)(a1);
-        }
-
-        template<class U> R operator()(U & u, A1 a1) const
-        {
-            (get_pointer(u)->*f_)(a1);
-        }
-
-        R operator()(T & t, A1 a1) const
-        {
-            (t.*f_)(a1);
-        }
-    };
-
-// cmf1_
-
-    template<class T, class A1, class F> class cmf1_
-    {
-     public:
-
-        typedef R result_type;
-        typedef T const * first_argument_type;
-        typedef A1 second_argument_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit cmf1_(F f): f_(f) {}
-
-        template<class U> R operator()(U const & u, A1 a1) const
-        {
-            (get_pointer(u)->*f_)(a1);
-        }
-
-        R operator()(T const & t, A1 a1) const
-        {
-            (t.*f_)(a1);
-        }
-    };
-
-// mf2_
-
-    template<class T, class A1, class A2, class F> class mf2_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit mf2_(F f): f_(f) {}
-
-        R operator()(T * p, A1 a1, A2 a2) const
-        {
-            (p->*f_)(a1, a2);
-        }
-
-        template<class U> R operator()(U & u, A1 a1, A2 a2) const
-        {
-            (get_pointer(u)->*f_)(a1, a2);
-        }
-
-        R operator()(T & t, A1 a1, A2 a2) const
-        {
-            (t.*f_)(a1, a2);
-        }
-    };
-
-// cmf2_
-
-    template<class T, class A1, class A2, class F> class cmf2_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit cmf2_(F f): f_(f) {}
-
-        template<class U> R operator()(U const & u, A1 a1, A2 a2) const
-        {
-            (get_pointer(u)->*f_)(a1, a2);
-        }
-
-        R operator()(T const & t, A1 a1, A2 a2) const
-        {
-            (t.*f_)(a1, a2);
-        }
-    };
-
-// mf3_
-
-    template<class T, class A1, class A2, class A3, class F> class mf3_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit mf3_(F f): f_(f) {}
-
-        R operator()(T * p, A1 a1, A2 a2, A3 a3) const
-        {
-            (p->*f_)(a1, a2, a3);
-        }
-
-        template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3) const
-        {
-            (get_pointer(u)->*f_)(a1, a2, a3);
-        }
-
-        R operator()(T & t, A1 a1, A2 a2, A3 a3) const
-        {
-            (t.*f_)(a1, a2, a3);
-        }
-    };
-
-// cmf3_
-
-    template<class T, class A1, class A2, class A3, class F> class cmf3_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-
-        F f_;
-
-     public:
-
-        explicit cmf3_(F f): f_(f) {}
-
-        template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
-        {
-            (get_pointer(u)->*f_)(a1, a2, a3);
-        }
-
-        R operator()(T const & t, A1 a1, A2 a2, A3 a3) const
-        {
-            (t.*f_)(a1, a2, a3);
-        }
-    };
-
-// mf4_
-
-    template<class T, class A1, class A2, class A3, class A4, class F> class mf4_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit mf4_(F f): f_(f) {}
-
-        R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4) const
-        {
-            (p->*f_)(a1, a2, a3, a4);
-        }
-
-        template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4) const
-        {
-            (get_pointer(u)->*f_)(a1, a2, a3, a4);
-        }
-
-        R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4) const
-        {
-            (t.*f_)(a1, a2, a3, a4);
-        }
-    };
-
-// cmf4_
-
-    template<class T, class A1, class A2, class A3, class A4, class F> class cmf4_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit cmf4_(F f): f_(f) {}
-
-        template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
-        {
-            (get_pointer(u)->*f_)(a1, a2, a3, a4);
-        }
-
-        R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4) const
-        {
-            (t.*f_)(a1, a2, a3, a4);
-        }
-    };
-
-// mf5_
-
-    template<class T, class A1, class A2, class A3, class A4, class A5, class F> class mf5_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit mf5_(F f): f_(f) {}
-
-        R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
-        {
-            (p->*f_)(a1, a2, a3, a4, a5);
-        }
-
-        template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
-        {
-            (get_pointer(u)->*f_)(a1, a2, a3, a4, a5);
-        }
-
-        R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
-        {
-            (t.*f_)(a1, a2, a3, a4, a5);
-        }
-    };
-
-// cmf5_
-
-    template<class T, class A1, class A2, class A3, class A4, class A5, class F> class cmf5_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit cmf5_(F f): f_(f) {}
-
-        template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
-        {
-            (get_pointer(u)->*f_)(a1, a2, a3, a4, a5);
-        }
-
-        R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
-        {
-            (t.*f_)(a1, a2, a3, a4, a5);
-        }
-    };
-
-// mf6_
-
-    template<class T, class A1, class A2, class A3, class A4, class A5, class A6, class F> class mf6_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-
-        F f_;
-
-     public:
-
-        explicit mf6_(F f): f_(f) {}
-
-        R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
-        {
-            (p->*f_)(a1, a2, a3, a4, a5, a6);
-        }
-
-        template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
-        {
-            (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6);
-        }
-
-        R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
-        {
-            (t.*f_)(a1, a2, a3, a4, a5, a6);
-        }
-    };
-
-// cmf6_
-
-    template<class T, class A1, class A2, class A3, class A4, class A5, class A6, class F> class cmf6_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit cmf6_(F f): f_(f) {}
-
-        template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
-        {
-            (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6);
-        }
-
-        R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
-        {
-            (t.*f_)(a1, a2, a3, a4, a5, a6);
-        }
-    };
-
-// mf7_
-
-    template<class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class F> class mf7_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit mf7_(F f): f_(f) {}
-
-        R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
-        {
-            (p->*f_)(a1, a2, a3, a4, a5, a6, a7);
-        }
-
-        template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
-        {
-            (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6, a7);
-        }
-
-        R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
-        {
-            (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
-        }
-    };
-
-// cmf7_
-
-    template<class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class F> class cmf7_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit cmf7_(F f): f_(f) {}
-
-        template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
-        {
-            (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6, a7);
-        }
-
-        R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
-        {
-            (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
-        }
-    };
-
-// mf8_
-
-    template<class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class F> class mf8_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit mf8_(F f): f_(f) {}
-
-        R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
-        {
-            (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
-        }
-
-        template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
-        {
-            (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
-        }
-
-        R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
-        {
-            (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
-        }
-    };
-
-// cmf8_
-
-    template<class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class F> class cmf8_
-    {
-     public:
-
-        typedef R result_type;
-
-     private:
-    
-        F f_;
-
-     public:
-    
-        explicit cmf8_(F f): f_(f) {}
-
-        R operator()(T const * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
-        {
-            (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
-        }
-
-        template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
-        {
-            (get_pointer(u)->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
-        }
-
-        R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
-        {
-            (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
-        }
-    };
-};
-
-#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
-#pragma warning(push)
-#pragma warning(disable: 4097) // typedef name 'mf0_' used as a synonym for class
 #endif
 
-template<class R, class T, class F = R (T::*) ()>
-class mf0: public mf<R>::template mf0_<T, F>
-{
-    typedef typename mf<R>::template mf0_<T, F> mf0_;
- public:
-    explicit mf0(F f): mf0_(f) {}
-};
+#undef BOOST_MEM_FN_RETURN
 
-template<class R, class T, class F = R (T::*) () const>
-class cmf0: public mf<R>::template cmf0_<T, F>
-{
-    typedef typename mf<R>::template cmf0_<T, F> cmf0_;
- public:
-    explicit cmf0(F f): cmf0_(f) {}
-};
+}; // struct mf<V>
 
-template<class R, class T, class A1, class F = R (T::*) (A1)>
-class mf1: public mf<R>::template mf1_<T, A1, F>
+template<> struct mf<void>
 {
-    typedef typename mf<R>::template mf1_<T, A1, F> mf1_;
- public:
-    explicit mf1(F f): mf1_(f) {}
-};
 
-template<class R, class T, class A1, class F = R (T::*) (A1) const>
-class cmf1: public mf<R>::template cmf1_<T, A1, F>
-{
-    typedef typename mf<R>::template cmf1_<T, A1, F> cmf1_;
- public:
-    explicit cmf1(F f): cmf1_(f) {}
-};
+#define BOOST_MEM_FN_RETURN
 
-template<class R, class T, class A1, class A2, class F = R (T::*) (A1, A2)>
-class mf2: public mf<R>::template mf2_<T, A1, A2, F>
-{
-    typedef typename mf<R>::template mf2_<T, A1, A2, F> mf2_;
- public:
-    explicit mf2(F f): mf2_(f) {}
-};
+#define BOOST_MEM_FN_NAME(X) inner_##X
+#define BOOST_MEM_FN_CC
 
-template<class R, class T, class A1, class A2, class F = R (T::*) (A1, A2) const>
-class cmf2: public mf<R>::template cmf2_<T, A1, A2, F>
-{
-    typedef typename mf<R>::template cmf2_<T, A1, A2, F> cmf2_;
- public:
-    explicit cmf2(F f): cmf2_(f) {}
-};
+#include <boost/bind/mem_fn_template.hpp>
 
-template<class R, class T, class A1, class A2, class A3, class F = R (T::*) (A1, A2, A3)>
-class mf3: public mf<R>::template mf3_<T, A1, A2, A3, F>
-{
-    typedef typename mf<R>::template mf3_<T, A1, A2, A3, F> mf3_;
- public:
-    explicit mf3(F f): mf3_(f) {}
-};
+#undef BOOST_MEM_FN_CC
+#undef BOOST_MEM_FN_NAME
 
-template<class R, class T, class A1, class A2, class A3, class F = R (T::*) (A1, A2, A3) const>
-class cmf3: public mf<R>::template cmf3_<T, A1, A2, A3, F>
-{
-    typedef typename mf<R>::template cmf3_<T, A1, A2, A3, F> cmf3_;
- public:
-    explicit cmf3(F f): cmf3_(f) {}
-};
+#ifdef BOOST_MEM_FN_ENABLE_STDCALL
 
-template<class R, class T, class A1, class A2, class A3, class A4, class F = R (T::*) (A1, A2, A3, A4)>
-class mf4: public mf<R>::template mf4_<T, A1, A2, A3, A4, F>
-{
-    typedef typename mf<R>::template mf4_<T, A1, A2, A3, A4, F> mf4_;
- public:
-    explicit mf4(F f): mf4_(f) {}
-};
+#define BOOST_MEM_FN_NAME(X) inner_##X##_stdcall
+#define BOOST_MEM_FN_CC __stdcall
 
-template<class R, class T, class A1, class A2, class A3, class A4, class F = R (T::*) (A1, A2, A3, A4) const>
-class cmf4: public mf<R>::template cmf4_<T, A1, A2, A3, A4, F>
-{
-    typedef typename mf<R>::template cmf4_<T, A1, A2, A3, A4, F> cmf4_;
- public:
-    explicit cmf4(F f): cmf4_(f) {}
-};
+#include <boost/bind/mem_fn_template.hpp>
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class F = R (T::*) (A1, A2, A3, A4, A5)>
-class mf5: public mf<R>::template mf5_<T, A1, A2, A3, A4, A5, F>
-{
-    typedef typename mf<R>::template mf5_<T, A1, A2, A3, A4, A5, F> mf5_;
- public:
-    explicit mf5(F f): mf5_(f) {}
-};
+#undef BOOST_MEM_FN_CC
+#undef BOOST_MEM_FN_NAME
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class F = R (T::*) (A1, A2, A3, A4, A5) const>
-class cmf5: public mf<R>::template cmf5_<T, A1, A2, A3, A4, A5, F>
-{
-    typedef typename mf<R>::template cmf5_<T, A1, A2, A3, A4, A5, F> cmf5_;
- public:
-    explicit cmf5(F f): cmf5_(f) {}
-};
+#endif
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class F = R (T::*) (A1, A2, A3, A4, A5, A6)>
-class mf6: public mf<R>::template mf6_<T, A1, A2, A3, A4, A5, A6, F>
-{
-    typedef typename mf<R>::template mf6_<T, A1, A2, A3, A4, A5, A6, F> mf6_;
- public:
-    explicit mf6(F f): mf6_(f) {}
-};
+#undef BOOST_MEM_FN_RETURN
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class F = R (T::*) (A1, A2, A3, A4, A5, A6) const>
-class cmf6: public mf<R>::template cmf6_<T, A1, A2, A3, A4, A5, A6, F>
-{
-    typedef typename mf<R>::template cmf6_<T, A1, A2, A3, A4, A5, A6, F> cmf6_;
- public:
-    explicit cmf6(F f): cmf6_(f) {}
-};
+}; // struct mf<void>
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class F = R (T::*) (A1, A2, A3, A4, A5, A6, A7)>
-class mf7: public mf<R>::template mf7_<T, A1, A2, A3, A4, A5, A6, A7, F>
-{
-    typedef typename mf<R>::template mf7_<T, A1, A2, A3, A4, A5, A6, A7, F> mf7_;
- public:
-    explicit mf7(F f): mf7_(f) {}
-};
+#define BOOST_MEM_FN_NAME(X) X
+#define BOOST_MEM_FN_NAME2(X) inner_##X
+#define BOOST_MEM_FN_CC
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class F = R (T::*) (A1, A2, A3, A4, A5, A6, A7) const>
-class cmf7: public mf<R>::template cmf7_<T, A1, A2, A3, A4, A5, A6, A7, F>
-{
-    typedef typename mf<R>::template cmf7_<T, A1, A2, A3, A4, A5, A6, A7, F> cmf7_;
- public:
-    explicit cmf7(F f): cmf7_(f) {}
-};
+#include <boost/bind/mem_fn_vw.hpp>
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class F = R (T::*) (A1, A2, A3, A4, A5, A6, A7, A8)>
-class mf8: public mf<R>::template mf8_<T, A1, A2, A3, A4, A5, A6, A7, A8, F>
-{
-    typedef typename mf<R>::template mf8_<T, A1, A2, A3, A4, A5, A6, A7, A8, F> mf8_;
- public:
-    explicit mf8(F f): mf8_(f) {}
-};
+#undef BOOST_MEM_FN_NAME
+#undef BOOST_MEM_FN_NAME2
+#undef BOOST_MEM_FN_CC
 
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class F = R (T::*) (A1, A2, A3, A4, A5, A6, A7, A8) const>
-class cmf8: public mf<R>::template cmf8_<T, A1, A2, A3, A4, A5, A6, A7, A8, F>
-{
-    typedef typename mf<R>::template cmf8_<T, A1, A2, A3, A4, A5, A6, A7, A8, F> cmf8_;
- public:
-    explicit cmf8(F f): cmf8_(f) {}
-};
+#ifdef BOOST_MEM_FN_ENABLE_STDCALL
+
+#define BOOST_MEM_FN_NAME(X) X##_stdcall
+#define BOOST_MEM_FN_NAME2(X) inner_##X##_stdcall
+#define BOOST_MEM_FN_CC __stdcall
+
+#include <boost/bind/mem_fn_vw.hpp>
+
+#undef BOOST_MEM_FN_NAME
+#undef BOOST_MEM_FN_NAME2
+#undef BOOST_MEM_FN_CC
 
-#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
-#pragma warning(pop)
 #endif
 
 } // namespace _mfi
 
-// mem_fn
+#else // #ifdef BOOST_NO_VOID_RETURNS
 
-// MSVC 7.0 and Metrowerks 7.1 can't handle the "main line"
+namespace _mfi
+{
 
-#if defined(BOOST_MEM_FN_ENABLE_STDCALL) || (defined(BOOST_MSVC) && BOOST_MSVC <= 1300) || (defined(__MWERKS__) && (__MWERKS__ <= 0x2406))
+#define BOOST_MEM_FN_RETURN return
+
+#define BOOST_MEM_FN_NAME(X) X
+#define BOOST_MEM_FN_CC
+
+#include <boost/bind/mem_fn_template.hpp>
 
-#if defined(BOOST_MEM_FN_ENABLE_STDCALL)
-#define BOOST_MEM_FN_CC __stdcall
-#include <boost/bind/mem_fn_cc.hpp>
 #undef BOOST_MEM_FN_CC
+#undef BOOST_MEM_FN_NAME
+
+#ifdef BOOST_MEM_FN_ENABLE_STDCALL
+
+#define BOOST_MEM_FN_NAME(X) X##_stdcall
+#define BOOST_MEM_FN_CC __stdcall
+
+#include <boost/bind/mem_fn_template.hpp>
+
+#undef BOOST_MEM_FN_CC
+#undef BOOST_MEM_FN_NAME
+
 #endif
 
+#undef BOOST_MEM_FN_RETURN
+
+} // namespace _mfi
+
+#endif // #ifdef BOOST_NO_VOID_RETURNS
+
+#define BOOST_MEM_FN_NAME(X) X
 #define BOOST_MEM_FN_CC
+
 #include <boost/bind/mem_fn_cc.hpp>
+
+#undef BOOST_MEM_FN_NAME
 #undef BOOST_MEM_FN_CC
 
-#else
+#ifdef BOOST_MEM_FN_ENABLE_STDCALL
 
-template<class R, class T> _mfi::mf0<R, T> mem_fn(R (T::*f) ())
-{
-    return _mfi::mf0<R, T>(f);
-}
+#define BOOST_MEM_FN_NAME(X) X##_stdcall
+#define BOOST_MEM_FN_CC __stdcall
 
-template<class R, class T> _mfi::cmf0<R, T> mem_fn(R (T::*f) () const)
-{
-    return _mfi::cmf0<R, T>(f);
-}
+#include <boost/bind/mem_fn_cc.hpp>
 
-template<class R, class T, class A1> _mfi::mf1<R, T, A1> mem_fn(R (T::*f) (A1))
-{
-    return _mfi::mf1<R, T, A1>(f);
-}
+#undef BOOST_MEM_FN_NAME
+#undef BOOST_MEM_FN_CC
 
-template<class R, class T, class A1> _mfi::cmf1<R, T, A1> mem_fn(R (T::*f) (A1) const)
-{
-    return _mfi::cmf1<R, T, A1>(f);
-}
-
-template<class R, class T, class A1, class A2> _mfi::mf2<R, T, A1, A2> mem_fn(R (T::*f) (A1, A2))
-{
-    return _mfi::mf2<R, T, A1, A2>(f);
-}
-
-template<class R, class T, class A1, class A2> _mfi::cmf2<R, T, A1, A2> mem_fn(R (T::*f) (A1, A2) const)
-{
-    return _mfi::cmf2<R, T, A1, A2>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3> _mfi::mf3<R, T, A1, A2, A3> mem_fn(R (T::*f) (A1, A2, A3))
-{
-    return _mfi::mf3<R, T, A1, A2, A3>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3> _mfi::cmf3<R, T, A1, A2, A3> mem_fn(R (T::*f) (A1, A2, A3) const)
-{
-    return _mfi::cmf3<R, T, A1, A2, A3>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3, class A4> _mfi::mf4<R, T, A1, A2, A3, A4> mem_fn(R (T::*f) (A1, A2, A3, A4))
-{
-    return _mfi::mf4<R, T, A1, A2, A3, A4>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3, class A4> _mfi::cmf4<R, T, A1, A2, A3, A4> mem_fn(R (T::*f) (A1, A2, A3, A4) const)
-{
-    return _mfi::cmf4<R, T, A1, A2, A3, A4>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::mf5<R, T, A1, A2, A3, A4, A5> mem_fn(R (T::*f) (A1, A2, A3, A4, A5))
-{
-    return _mfi::mf5<R, T, A1, A2, A3, A4, A5>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::cmf5<R, T, A1, A2, A3, A4, A5> mem_fn(R (T::*f) (A1, A2, A3, A4, A5) const)
-{
-    return _mfi::cmf5<R, T, A1, A2, A3, A4, A5>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R (T::*f) (A1, A2, A3, A4, A5, A6))
-{
-    return _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R (T::*f) (A1, A2, A3, A4, A5, A6) const)
-{
-    return _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R (T::*f) (A1, A2, A3, A4, A5, A6, A7))
-{
-    return _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R (T::*f) (A1, A2, A3, A4, A5, A6, A7) const)
-{
-    return _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R (T::*f) (A1, A2, A3, A4, A5, A6, A7, A8))
-{
-    return _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
-}
-
-template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R (T::*f) (A1, A2, A3, A4, A5, A6, A7, A8) const)
-{
-    return _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
-}
-
-#endif // !defined(BOOST_MEM_FN_ENABLE_STDCALL)
+#endif
 
 } // namespace boost