diff --git a/include/boost/bind.hpp b/include/boost/bind.hpp
index 7597244..ef1f909 100644
--- a/include/boost/bind.hpp
+++ b/include/boost/bind.hpp
@@ -26,6 +26,7 @@
 #include <boost/mem_fn.hpp>
 #include <boost/type.hpp>
 #include <boost/bind/arg.hpp>
+#include <boost/bind/storage.hpp>
 #include <boost/detail/workaround.hpp>
 
 // Borland-specific bug, visit_each() silently fails to produce code
@@ -72,12 +73,22 @@ template<class F> struct result_traits< unspecified, reference_wrapper<F> >
 
 // ref_compare
 
-template<class T> bool ref_compare(T const & a, T const & b, long)
+template<class T> bool ref_compare( T const & a, T const & b, long )
 {
     return a == b;
 }
 
-template<class T> bool ref_compare(reference_wrapper<T> const & a, reference_wrapper<T> const & b, int)
+template<int I> bool ref_compare( arg<I> const &, arg<I> const &, int )
+{
+    return true;
+}
+
+template<int I> bool ref_compare( arg<I> (*) (), arg<I> (*) (), int )
+{
+    return true;
+}
+
+template<class T> bool ref_compare( reference_wrapper<T> const & a, reference_wrapper<T> const & b, int )
 {
     return a.get_pointer() == b.get_pointer();
 }
@@ -179,15 +190,19 @@ public:
     }
 };
 
-template<class A1> class list1
+template< class A1 > class list1: private storage1< A1 >
 {
+private:
+
+    typedef storage1< A1 > base_type;
+
 public:
 
-    explicit list1(A1 a1): a1_(a1) {}
+    explicit list1( A1 a1 ): base_type( a1 ) {}
 
-    A1 operator[] (boost::arg<1>) const { return a1_; }
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
 
-    A1 operator[] (boost::arg<1> (*) ()) const { return a1_; }
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
 
     template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
 
@@ -201,50 +216,50 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
     {
-        return unwrapper<F>::unwrap(f, 0)(a[a1_]);
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
     }
 
     template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
     {
-        return unwrapper<F const>::unwrap(f, 0)(a[a1_]);
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
     }
 
     template<class F, class A> void operator()(type<void>, F & f, A & a, int)
     {
-        unwrapper<F>::unwrap(f, 0)(a[a1_]);
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
     }
 
     template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
     {
-        unwrapper<F const>::unwrap(f, 0)(a[a1_]);
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
     }
 
     template<class V> void accept(V & v) const
     {
-        BOOST_BIND_VISIT_EACH(v, a1_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a1_, 0);
     }
 
     bool operator==(list1 const & rhs) const
     {
-        return ref_compare(a1_, rhs.a1_, 0);
+        return ref_compare(base_type::a1_, rhs.a1_, 0);
     }
-
-private:
-
-    A1 a1_;
 };
 
-template<class A1, class A2> class list2
+template< class A1, class A2 > class list2: private storage2< A1, A2 >
 {
+private:
+
+    typedef storage2< A1, A2 > base_type;
+
 public:
 
-    list2(A1 a1, A2 a2): a1_(a1), a2_(a2) {}
+    list2( A1 a1, A2 a2 ): base_type( a1, a2 ) {}
 
-    A1 operator[] (boost::arg<1>) const { return a1_; }
-    A2 operator[] (boost::arg<2>) const { return a2_; }
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
 
-    A1 operator[] (boost::arg<1> (*) ()) const { return a1_; }
-    A2 operator[] (boost::arg<2> (*) ()) const { return a2_; }
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
 
     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
@@ -258,54 +273,53 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
     {
-        return unwrapper<F>::unwrap(f, 0)(a[a1_], a[a2_]);
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
     }
 
     template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
     {
-        return unwrapper<F const>::unwrap(f, 0)(a[a1_], a[a2_]);
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
     }
 
     template<class F, class A> void operator()(type<void>, F & f, A & a, int)
     {
-        unwrapper<F>::unwrap(f, 0)(a[a1_], a[a2_]);
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
     }
 
     template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
     {
-        unwrapper<F const>::unwrap(f, 0)(a[a1_], a[a2_]);
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
     }
 
     template<class V> void accept(V & v) const
     {
-        BOOST_BIND_VISIT_EACH(v, a1_, 0);
-        BOOST_BIND_VISIT_EACH(v, a2_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a1_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a2_, 0);
     }
 
     bool operator==(list2 const & rhs) const
     {
-        return ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0);
+        return ref_compare(base_type::a1_, rhs.a1_, 0) && ref_compare(base_type::a2_, rhs.a2_, 0);
     }
-
-private:
-
-    A1 a1_;
-    A2 a2_;
 };
 
-template<class A1, class A2, class A3> class list3
+template< class A1, class A2, class A3 > class list3: private storage3< A1, A2, A3 >
 {
+private:
+
+    typedef storage3< A1, A2, A3 > base_type;
+
 public:
 
-    list3(A1 a1, A2 a2, A3 a3): a1_(a1), a2_(a2), a3_(a3) {}
+    list3( A1 a1, A2 a2, A3 a3 ): base_type( a1, a2, a3 ) {}
 
-    A1 operator[] (boost::arg<1>) const { return a1_; }
-    A2 operator[] (boost::arg<2>) const { return a2_; }
-    A3 operator[] (boost::arg<3>) const { return a3_; }
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
 
-    A1 operator[] (boost::arg<1> (*) ()) const { return a1_; }
-    A2 operator[] (boost::arg<2> (*) ()) const { return a2_; }
-    A3 operator[] (boost::arg<3> (*) ()) const { return a3_; }
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
 
     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
@@ -319,58 +333,60 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
     {
-        return unwrapper<F>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_]);
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
     }
 
     template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
     {
-        return unwrapper<F const>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_]);
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
     }
 
     template<class F, class A> void operator()(type<void>, F & f, A & a, int)
     {
-        unwrapper<F>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_]);
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
     }
 
     template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
     {
-        unwrapper<F const>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_]);
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
     }
 
     template<class V> void accept(V & v) const
     {
-        BOOST_BIND_VISIT_EACH(v, a1_, 0);
-        BOOST_BIND_VISIT_EACH(v, a2_, 0);
-        BOOST_BIND_VISIT_EACH(v, a3_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a1_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a2_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a3_, 0);
     }
 
     bool operator==(list3 const & rhs) const
     {
-        return ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0);
+        return
+            
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 );
     }
-
-private:
-
-    A1 a1_;
-    A2 a2_;
-    A3 a3_;
 };
 
-template<class A1, class A2, class A3, class A4> class list4
+template< class A1, class A2, class A3, class A4 > class list4: private storage4< A1, A2, A3, A4 >
 {
+private:
+
+    typedef storage4< A1, A2, A3, A4 > base_type;
+
 public:
 
-    list4(A1 a1, A2 a2, A3 a3, A4 a4): a1_(a1), a2_(a2), a3_(a3), a4_(a4) {}
+    list4( A1 a1, A2 a2, A3 a3, A4 a4 ): base_type( a1, a2, a3, a4 ) {}
 
-    A1 operator[] (boost::arg<1>) const { return a1_; }
-    A2 operator[] (boost::arg<2>) const { return a2_; }
-    A3 operator[] (boost::arg<3>) const { return a3_; }
-    A4 operator[] (boost::arg<4>) const { return a4_; }
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
 
-    A1 operator[] (boost::arg<1> (*) ()) const { return a1_; }
-    A2 operator[] (boost::arg<2> (*) ()) const { return a2_; }
-    A3 operator[] (boost::arg<3> (*) ()) const { return a3_; }
-    A4 operator[] (boost::arg<4> (*) ()) const { return a4_; }
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
 
     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
@@ -384,64 +400,64 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
     {
-        return unwrapper<F>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
     }
 
     template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
     {
-        return unwrapper<F const>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
     }
 
     template<class F, class A> void operator()(type<void>, F & f, A & a, int)
     {
-        unwrapper<F>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
     }
 
     template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
     {
-        unwrapper<F const>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
     }
 
     template<class V> void accept(V & v) const
     {
-        BOOST_BIND_VISIT_EACH(v, a1_, 0);
-        BOOST_BIND_VISIT_EACH(v, a2_, 0);
-        BOOST_BIND_VISIT_EACH(v, a3_, 0);
-        BOOST_BIND_VISIT_EACH(v, a4_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a1_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a2_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a3_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a4_, 0);
     }
 
     bool operator==(list4 const & rhs) const
     {
         return
-            ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) &&
-            ref_compare(a4_, rhs.a4_, 0);
+
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 );
     }
-
-private:
-
-    A1 a1_;
-    A2 a2_;
-    A3 a3_;
-    A4 a4_;
 };
 
-template<class A1, class A2, class A3, class A4, class A5> class list5
+template< class A1, class A2, class A3, class A4, class A5 > class list5: private storage5< A1, A2, A3, A4, A5 >
 {
+private:
+
+    typedef storage5< A1, A2, A3, A4, A5 > base_type;
+
 public:
 
-    list5(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5): a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5) {}
+    list5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): base_type( a1, a2, a3, a4, a5 ) {}
 
-    A1 operator[] (boost::arg<1>) const { return a1_; }
-    A2 operator[] (boost::arg<2>) const { return a2_; }
-    A3 operator[] (boost::arg<3>) const { return a3_; }
-    A4 operator[] (boost::arg<4>) const { return a4_; }
-    A5 operator[] (boost::arg<5>) const { return a5_; }
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
 
-    A1 operator[] (boost::arg<1> (*) ()) const { return a1_; }
-    A2 operator[] (boost::arg<2> (*) ()) const { return a2_; }
-    A3 operator[] (boost::arg<3> (*) ()) const { return a3_; }
-    A4 operator[] (boost::arg<4> (*) ()) const { return a4_; }
-    A5 operator[] (boost::arg<5> (*) ()) const { return a5_; }
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
 
     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
@@ -455,68 +471,68 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
     {
-        return unwrapper<F>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
     }
 
     template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
     {
-        return unwrapper<F const>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
     }
 
     template<class F, class A> void operator()(type<void>, F & f, A & a, int)
     {
-        unwrapper<F>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
     }
 
     template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
     {
-        unwrapper<F const>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
     }
 
     template<class V> void accept(V & v) const
     {
-        BOOST_BIND_VISIT_EACH(v, a1_, 0);
-        BOOST_BIND_VISIT_EACH(v, a2_, 0);
-        BOOST_BIND_VISIT_EACH(v, a3_, 0);
-        BOOST_BIND_VISIT_EACH(v, a4_, 0);
-        BOOST_BIND_VISIT_EACH(v, a5_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a1_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a2_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a3_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a4_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a5_, 0);
     }
 
     bool operator==(list5 const & rhs) const
     {
         return
-            ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) &&
-            ref_compare(a4_, rhs.a4_, 0) && ref_compare(a5_, rhs.a5_, 0);
+
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
+            ref_compare( base_type::a5_, rhs.a5_, 0 );
     }
-
-private:
-
-    A1 a1_;
-    A2 a2_;
-    A3 a3_;
-    A4 a4_;
-    A5 a5_;
 };
 
-template<class A1, class A2, class A3, class A4, class A5, class A6> class list6
+template<class A1, class A2, class A3, class A4, class A5, class A6> class list6: private storage6< A1, A2, A3, A4, A5, A6 >
 {
+private:
+
+    typedef storage6< A1, A2, A3, A4, A5, A6 > base_type;
+
 public:
 
-    list6(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6): a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6) {}
+    list6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): base_type( a1, a2, a3, a4, a5, a6 ) {}
 
-    A1 operator[] (boost::arg<1>) const { return a1_; }
-    A2 operator[] (boost::arg<2>) const { return a2_; }
-    A3 operator[] (boost::arg<3>) const { return a3_; }
-    A4 operator[] (boost::arg<4>) const { return a4_; }
-    A5 operator[] (boost::arg<5>) const { return a5_; }
-    A6 operator[] (boost::arg<6>) const { return a6_; }
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
 
-    A1 operator[] (boost::arg<1> (*) ()) const { return a1_; }
-    A2 operator[] (boost::arg<2> (*) ()) const { return a2_; }
-    A3 operator[] (boost::arg<3> (*) ()) const { return a3_; }
-    A4 operator[] (boost::arg<4> (*) ()) const { return a4_; }
-    A5 operator[] (boost::arg<5> (*) ()) const { return a5_; }
-    A6 operator[] (boost::arg<6> (*) ()) const { return a6_; }
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
 
     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
@@ -530,72 +546,72 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
     {
-        return unwrapper<F>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
     }
 
     template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
     {
-        return unwrapper<F const>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
     }
 
     template<class F, class A> void operator()(type<void>, F & f, A & a, int)
     {
-        unwrapper<F>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
     }
 
     template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
     {
-        unwrapper<F const>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
     }
 
     template<class V> void accept(V & v) const
     {
-        BOOST_BIND_VISIT_EACH(v, a1_, 0);
-        BOOST_BIND_VISIT_EACH(v, a2_, 0);
-        BOOST_BIND_VISIT_EACH(v, a3_, 0);
-        BOOST_BIND_VISIT_EACH(v, a4_, 0);
-        BOOST_BIND_VISIT_EACH(v, a5_, 0);
-        BOOST_BIND_VISIT_EACH(v, a6_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a1_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a2_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a3_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a4_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a5_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a6_, 0);
     }
 
     bool operator==(list6 const & rhs) const
     {
         return
-            ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) &&
-            ref_compare(a4_, rhs.a4_, 0) && ref_compare(a5_, rhs.a5_, 0) && ref_compare(a6_, rhs.a6_, 0);
+
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
+            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
+            ref_compare( base_type::a6_, rhs.a6_, 0 );
     }
-
-private:
-
-    A1 a1_;
-    A2 a2_;
-    A3 a3_;
-    A4 a4_;
-    A5 a5_;
-    A6 a6_;
 };
 
-template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> class list7
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> class list7: private storage7< A1, A2, A3, A4, A5, A6, A7 >
 {
+private:
+
+    typedef storage7< A1, A2, A3, A4, A5, A6, A7 > base_type;
+
 public:
 
-    list7(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7): a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7) {}
+    list7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): base_type( a1, a2, a3, a4, a5, a6, a7 ) {}
 
-    A1 operator[] (boost::arg<1>) const { return a1_; }
-    A2 operator[] (boost::arg<2>) const { return a2_; }
-    A3 operator[] (boost::arg<3>) const { return a3_; }
-    A4 operator[] (boost::arg<4>) const { return a4_; }
-    A5 operator[] (boost::arg<5>) const { return a5_; }
-    A6 operator[] (boost::arg<6>) const { return a6_; }
-    A7 operator[] (boost::arg<7>) const { return a7_; }
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
 
-    A1 operator[] (boost::arg<1> (*) ()) const { return a1_; }
-    A2 operator[] (boost::arg<2> (*) ()) const { return a2_; }
-    A3 operator[] (boost::arg<3> (*) ()) const { return a3_; }
-    A4 operator[] (boost::arg<4> (*) ()) const { return a4_; }
-    A5 operator[] (boost::arg<5> (*) ()) const { return a5_; }
-    A6 operator[] (boost::arg<6> (*) ()) const { return a6_; }
-    A7 operator[] (boost::arg<7> (*) ()) const { return a7_; }
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
 
     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
@@ -609,77 +625,76 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
     {
-        return unwrapper<F>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
     }
 
     template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
     {
-        return unwrapper<F const>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
     }
 
     template<class F, class A> void operator()(type<void>, F & f, A & a, int)
     {
-        unwrapper<F>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
     }
 
     template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
     {
-        unwrapper<F const>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
     }
 
     template<class V> void accept(V & v) const
     {
-        BOOST_BIND_VISIT_EACH(v, a1_, 0);
-        BOOST_BIND_VISIT_EACH(v, a2_, 0);
-        BOOST_BIND_VISIT_EACH(v, a3_, 0);
-        BOOST_BIND_VISIT_EACH(v, a4_, 0);
-        BOOST_BIND_VISIT_EACH(v, a5_, 0);
-        BOOST_BIND_VISIT_EACH(v, a6_, 0);
-        BOOST_BIND_VISIT_EACH(v, a7_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a1_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a2_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a3_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a4_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a5_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a6_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a7_, 0);
     }
 
     bool operator==(list7 const & rhs) const
     {
         return
-            ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) &&
-            ref_compare(a4_, rhs.a4_, 0) && ref_compare(a5_, rhs.a5_, 0) && ref_compare(a6_, rhs.a6_, 0) &&
-            ref_compare(a7_, rhs.a7_, 0);
+
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
+            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
+            ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
+            ref_compare( base_type::a7_, rhs.a7_, 0 );
     }
-
-private:
-
-    A1 a1_;
-    A2 a2_;
-    A3 a3_;
-    A4 a4_;
-    A5 a5_;
-    A6 a6_;
-    A7 a7_;
 };
 
-template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> class list8
+template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class list8: private storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
 {
+private:
+
+    typedef storage8< A1, A2, A3, A4, A5, A6, A7, A8 > base_type;
+
 public:
 
-    list8(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8): a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8) {}
+    list8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8 ) {}
 
-    A1 operator[] (boost::arg<1>) const { return a1_; }
-    A2 operator[] (boost::arg<2>) const { return a2_; }
-    A3 operator[] (boost::arg<3>) const { return a3_; }
-    A4 operator[] (boost::arg<4>) const { return a4_; }
-    A5 operator[] (boost::arg<5>) const { return a5_; }
-    A6 operator[] (boost::arg<6>) const { return a6_; }
-    A7 operator[] (boost::arg<7>) const { return a7_; }
-    A8 operator[] (boost::arg<8>) const { return a8_; }
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
+    A8 operator[] (boost::arg<8>) const { return base_type::a8_; }
 
-    A1 operator[] (boost::arg<1> (*) ()) const { return a1_; }
-    A2 operator[] (boost::arg<2> (*) ()) const { return a2_; }
-    A3 operator[] (boost::arg<3> (*) ()) const { return a3_; }
-    A4 operator[] (boost::arg<4> (*) ()) const { return a4_; }
-    A5 operator[] (boost::arg<5> (*) ()) const { return a5_; }
-    A6 operator[] (boost::arg<6> (*) ()) const { return a6_; }
-    A7 operator[] (boost::arg<7> (*) ()) const { return a7_; }
-    A8 operator[] (boost::arg<8> (*) ()) const { return a8_; }
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
+    A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }
 
     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
@@ -693,81 +708,80 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
     {
-        return unwrapper<F>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
     }
 
     template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
     {
-        return unwrapper<F const>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
     }
 
     template<class F, class A> void operator()(type<void>, F & f, A & a, int)
     {
-        unwrapper<F>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
     }
 
     template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
     {
-        unwrapper<F const>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
     }
 
     template<class V> void accept(V & v) const
     {
-        BOOST_BIND_VISIT_EACH(v, a1_, 0);
-        BOOST_BIND_VISIT_EACH(v, a2_, 0);
-        BOOST_BIND_VISIT_EACH(v, a3_, 0);
-        BOOST_BIND_VISIT_EACH(v, a4_, 0);
-        BOOST_BIND_VISIT_EACH(v, a5_, 0);
-        BOOST_BIND_VISIT_EACH(v, a6_, 0);
-        BOOST_BIND_VISIT_EACH(v, a7_, 0);
-        BOOST_BIND_VISIT_EACH(v, a8_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a1_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a2_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a3_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a4_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a5_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a6_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a7_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a8_, 0);
     }
 
     bool operator==(list8 const & rhs) const
     {
         return
-            ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) &&
-            ref_compare(a4_, rhs.a4_, 0) && ref_compare(a5_, rhs.a5_, 0) && ref_compare(a6_, rhs.a6_, 0) &&
-            ref_compare(a7_, rhs.a7_, 0) && ref_compare(a8_, rhs.a8_, 0);
+            
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
+            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
+            ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
+            ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
+            ref_compare( base_type::a8_, rhs.a8_, 0 );
     }
-
-private:
-
-    A1 a1_;
-    A2 a2_;
-    A3 a3_;
-    A4 a4_;
-    A5 a5_;
-    A6 a6_;
-    A7 a7_;
-    A8 a8_;
 };
 
-template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> class list9
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> class list9: private storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 >
 {
+private:
+
+    typedef storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > base_type;
+
 public:
 
-    list9(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9): a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9) {}
+    list9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8, a9 ) {}
 
-    A1 operator[] (boost::arg<1>) const { return a1_; }
-    A2 operator[] (boost::arg<2>) const { return a2_; }
-    A3 operator[] (boost::arg<3>) const { return a3_; }
-    A4 operator[] (boost::arg<4>) const { return a4_; }
-    A5 operator[] (boost::arg<5>) const { return a5_; }
-    A6 operator[] (boost::arg<6>) const { return a6_; }
-    A7 operator[] (boost::arg<7>) const { return a7_; }
-    A8 operator[] (boost::arg<8>) const { return a8_; }
-    A9 operator[] (boost::arg<9>) const { return a9_; }
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
+    A8 operator[] (boost::arg<8>) const { return base_type::a8_; }
+    A9 operator[] (boost::arg<9>) const { return base_type::a9_; }
 
-    A1 operator[] (boost::arg<1> (*) ()) const { return a1_; }
-    A2 operator[] (boost::arg<2> (*) ()) const { return a2_; }
-    A3 operator[] (boost::arg<3> (*) ()) const { return a3_; }
-    A4 operator[] (boost::arg<4> (*) ()) const { return a4_; }
-    A5 operator[] (boost::arg<5> (*) ()) const { return a5_; }
-    A6 operator[] (boost::arg<6> (*) ()) const { return a6_; }
-    A7 operator[] (boost::arg<7> (*) ()) const { return a7_; }
-    A8 operator[] (boost::arg<8> (*) ()) const { return a8_; }
-    A9 operator[] (boost::arg<9> (*) ()) const { return a9_; }
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
+    A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }
+    A9 operator[] (boost::arg<9> (*) ()) const { return base_type::a9_; }
 
     template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
 
@@ -781,56 +795,51 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
     {
-        return unwrapper<F>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
     }
 
     template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
     {
-        return unwrapper<F const>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
     }
 
     template<class F, class A> void operator()(type<void>, F & f, A & a, int)
     {
-        unwrapper<F>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
     }
 
     template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
     {
-        unwrapper<F const>::unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
     }
 
     template<class V> void accept(V & v) const
     {
-        BOOST_BIND_VISIT_EACH(v, a1_, 0);
-        BOOST_BIND_VISIT_EACH(v, a2_, 0);
-        BOOST_BIND_VISIT_EACH(v, a3_, 0);
-        BOOST_BIND_VISIT_EACH(v, a4_, 0);
-        BOOST_BIND_VISIT_EACH(v, a5_, 0);
-        BOOST_BIND_VISIT_EACH(v, a6_, 0);
-        BOOST_BIND_VISIT_EACH(v, a7_, 0);
-        BOOST_BIND_VISIT_EACH(v, a8_, 0);
-        BOOST_BIND_VISIT_EACH(v, a9_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a1_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a2_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a3_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a4_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a5_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a6_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a7_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a8_, 0);
+        BOOST_BIND_VISIT_EACH(v, base_type::a9_, 0);
     }
 
     bool operator==(list9 const & rhs) const
     {
         return
-            ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) &&
-            ref_compare(a4_, rhs.a4_, 0) && ref_compare(a5_, rhs.a5_, 0) && ref_compare(a6_, rhs.a6_, 0) &&
-            ref_compare(a7_, rhs.a7_, 0) && ref_compare(a8_, rhs.a8_, 0) && ref_compare(a9_, rhs.a9_, 0);
+
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
+            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
+            ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
+            ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
+            ref_compare( base_type::a8_, rhs.a8_, 0 ) &&
+            ref_compare( base_type::a9_, rhs.a9_, 0 );
     }
-
-private:
-
-    A1 a1_;
-    A2 a2_;
-    A3 a3_;
-    A4 a4_;
-    A5 a5_;
-    A6 a6_;
-    A7 a7_;
-    A8 a8_;
-    A9 a9_;
 };
 
 // bind_t
diff --git a/include/boost/bind/storage.hpp b/include/boost/bind/storage.hpp
new file mode 100644
index 0000000..298707f
--- /dev/null
+++ b/include/boost/bind/storage.hpp
@@ -0,0 +1,280 @@
+#ifndef BOOST_BIND_STORAGE_HPP_INCLUDED
+#define BOOST_BIND_STORAGE_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  bind/storage.hpp
+//
+//  boost/bind.hpp support header, optimized storage
+//
+//  Copyright (c) 2006 Peter Dimov
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt
+//
+//  See http://www.boost.org/libs/bind/bind.html for documentation.
+//
+
+#include <boost/config.hpp>
+#include <boost/bind/arg.hpp>
+
+namespace boost
+{
+
+namespace _bi
+{
+
+// 1
+
+template<class A1> struct storage1
+{
+    explicit storage1( A1 a1 ): a1_( a1 ) {}
+
+    A1 a1_;
+};
+
+#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined( __BORLANDC__ )
+
+template<int I> struct storage1< boost::arg<I> >
+{
+    explicit storage1( boost::arg<I> ) {}
+
+    static boost::arg<I> a1_() { return boost::arg<I>(); }
+};
+
+template<int I> struct storage1< boost::arg<I> (*) () >
+{
+    explicit storage1( boost::arg<I> (*) () ) {}
+
+    static boost::arg<I> a1_() { return boost::arg<I>(); }
+};
+
+#endif
+
+// 2
+
+template<class A1, class A2> struct storage2: public storage1<A1>
+{
+    storage2( A1 a1, A2 a2 ): storage1<A1>( a1 ), a2_( a2 ) {}
+
+    A2 a2_;
+};
+
+#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
+
+template<class A1, int I> struct storage2< A1, boost::arg<I> >: public storage1<A1>
+{
+    storage2( A1 a1, boost::arg<I> ): storage1<A1>( a1 ) {}
+
+    static boost::arg<I> a2_() { return boost::arg<I>(); }
+};
+
+template<class A1, int I> struct storage2< A1, boost::arg<I> (*) () >: public storage1<A1>
+{
+    storage2( A1 a1, boost::arg<I> (*) () ): storage1<A1>( a1 ) {}
+
+    static boost::arg<I> a2_() { return boost::arg<I>(); }
+};
+
+#endif
+
+// 3
+
+template<class A1, class A2, class A3> struct storage3: public storage2< A1, A2 >
+{
+    storage3( A1 a1, A2 a2, A3 a3 ): storage2<A1, A2>( a1, a2 ), a3_( a3 ) {}
+
+    A3 a3_;
+};
+
+#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
+
+template<class A1, class A2, int I> struct storage3< A1, A2, boost::arg<I> >: public storage2< A1, A2 >
+{
+    storage3( A1 a1, A2 a2, boost::arg<I> ): storage2<A1, A2>( a1, a2 ) {}
+
+    static boost::arg<I> a3_() { return boost::arg<I>(); }
+};
+
+template<class A1, class A2, int I> struct storage3< A1, A2, boost::arg<I> (*) () >: public storage2< A1, A2 >
+{
+    storage3( A1 a1, A2 a2, boost::arg<I> (*) () ): storage2<A1, A2>( a1, a2 ) {}
+
+    static boost::arg<I> a3_() { return boost::arg<I>(); }
+};
+
+#endif
+
+// 4
+
+template<class A1, class A2, class A3, class A4> struct storage4: public storage3< A1, A2, A3 >
+{
+    storage4( A1 a1, A2 a2, A3 a3, A4 a4 ): storage3<A1, A2, A3>( a1, a2, a3 ), a4_( a4 ) {}
+
+    A4 a4_;
+};
+
+#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
+
+template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, boost::arg<I> >: public storage3< A1, A2, A3 >
+{
+    storage4( A1 a1, A2 a2, A3 a3, boost::arg<I> ): storage3<A1, A2, A3>( a1, a2, a3 ) {}
+
+    static boost::arg<I> a4_() { return boost::arg<I>(); }
+};
+
+template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, boost::arg<I> (*) () >: public storage3< A1, A2, A3 >
+{
+    storage4( A1 a1, A2 a2, A3 a3, boost::arg<I> (*) () ): storage3<A1, A2, A3>( a1, a2, a3 ) {}
+
+    static boost::arg<I> a4_() { return boost::arg<I>(); }
+};
+
+#endif
+
+// 5
+
+template<class A1, class A2, class A3, class A4, class A5> struct storage5: public storage4< A1, A2, A3, A4 >
+{
+    storage5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ), a5_( a5 ) {}
+
+    A5 a5_;
+};
+
+#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
+
+template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, boost::arg<I> >: public storage4< A1, A2, A3, A4 >
+{
+    storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<I> ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}
+
+    static boost::arg<I> a5_() { return boost::arg<I>(); }
+};
+
+template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, boost::arg<I> (*) () >: public storage4< A1, A2, A3, A4 >
+{
+    storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<I> (*) () ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}
+
+    static boost::arg<I> a5_() { return boost::arg<I>(); }
+};
+
+#endif
+
+// 6
+
+template<class A1, class A2, class A3, class A4, class A5, class A6> struct storage6: public storage5< A1, A2, A3, A4, A5 >
+{
+    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ), a6_( a6 ) {}
+
+    A6 a6_;
+};
+
+#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
+
+template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, boost::arg<I> >: public storage5< A1, A2, A3, A4, A5 >
+{
+    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<I> ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}
+
+    static boost::arg<I> a6_() { return boost::arg<I>(); }
+};
+
+template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, boost::arg<I> (*) () >: public storage5< A1, A2, A3, A4, A5 >
+{
+    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<I> (*) () ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}
+
+    static boost::arg<I> a6_() { return boost::arg<I>(); }
+};
+
+#endif
+
+// 7
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct storage7: public storage6< A1, A2, A3, A4, A5, A6 >
+{
+    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ), a7_( a7 ) {}
+
+    A7 a7_;
+};
+
+#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<I> >: public storage6< A1, A2, A3, A4, A5, A6 >
+{
+    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<I> ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}
+
+    static boost::arg<I> a7_() { return boost::arg<I>(); }
+};
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<I> (*) () >: public storage6< A1, A2, A3, A4, A5, A6 >
+{
+    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<I> (*) () ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}
+
+    static boost::arg<I> a7_() { return boost::arg<I>(); }
+};
+
+#endif
+
+// 8
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct storage8: public storage7< A1, A2, A3, A4, A5, A6, A7 >
+{
+    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8 ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ), a8_( a8 ) {}
+
+    A8 a8_;
+};
+
+#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<I> >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
+{
+    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg<I> ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ) {}
+
+    static boost::arg<I> a8_() { return boost::arg<I>(); }
+};
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<I> (*) () >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
+{
+    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg<I> (*) () ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ) {}
+
+    static boost::arg<I> a8_() { return boost::arg<I>(); }
+};
+
+#endif
+
+// 9
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct storage9: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
+{
+    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9 ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ), a9_( a9 ) {}
+
+    A9 a9_;
+};
+
+#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<I> >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
+{
+    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg<I> ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}
+
+    static boost::arg<I> a9_() { return boost::arg<I>(); }
+};
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<I> (*) () >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
+{
+    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg<I> (*) () ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}
+
+    static boost::arg<I> a9_() { return boost::arg<I>(); }
+};
+
+#endif
+
+} // namespace _bi
+
+} // namespace boost
+
+#endif // #ifndef BOOST_BIND_STORAGE_HPP_INCLUDED