#ifndef BOOST_BIND_HPP_INCLUDED

#define BOOST_BIND_HPP_INCLUDED

// MS compatible compilers support #pragma once

#if defined(_MSC_VER) && (_MSC_VER >= 1020)

# pragma once

#endif

//

//  bind.hpp - binds function objects to arguments

//

//  Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd.

//  Copyright (c) 2001 David Abrahams

//  Copyright (c) 2005 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/ref.hpp>

#include <boost/mem_fn.hpp>

#include <boost/type.hpp>

#include <boost/bind/arg.hpp>

#include <boost/detail/workaround.hpp>

#include <boost/visit_each.hpp>

// Borland-specific bug, visit_each() silently fails to produce code

#if defined(__BORLANDC__)

#  define BOOST_BIND_VISIT_EACH boost::visit_each

#else

#  define BOOST_BIND_VISIT_EACH visit_each

#endif

#include <boost/bind/storage.hpp>

#ifdef BOOST_MSVC

# pragma warning(push)

# pragma warning(disable: 4512) // assignment operator could not be generated

#endif

namespace boost

{

namespace _bi // implementation details

{

// result_traits

template<class R, class F> struct result_traits

{

    typedef R type;

};

#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)

struct unspecified {};

template<class F> struct result_traits<unspecified, F>

{

    typedef typename F::result_type type;

};

template<class F> struct result_traits< unspecified, reference_wrapper<F> >

{

    typedef typename F::result_type type;

};

#endif

// ref_compare

template<class T> bool ref_compare( T const & a, T const & b, long )

{

    return a == b;

}

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

}

// bind_t forward declaration for listN

template<class R, class F, class L> class bind_t;

// value

template<class T> class value

{

public:

    value(T const & t): t_(t) {}

    T & get() { return t_; }

    T const & get() const { return t_; }

    bool operator==(value const & rhs) const

    {

        return t_ == rhs.t_;

    }

private:

    T t_;

};

// type

template<class T> class type {};

// unwrap

template<class F> struct unwrapper

{

    static inline F & unwrap( F & f, long )

    {

        return f;

    }

    template<class F2> static inline F2 & unwrap( reference_wrapper<F2> rf, int )

    {

        return rf.get();

    }

    template<class R, class T> static inline _mfi::dm<R, T> unwrap( R T::* pm, int )

    {

        return _mfi::dm<R, T>( pm );

    }

};

// listN

class list0

{

public:

    list0() {}

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A &, long)

    {

        return unwrapper<F>::unwrap(f, 0)();

    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const

    {

        return unwrapper<F const>::unwrap(f, 0)();

    }

    template<class F, class A> void operator()(type<void>, F & f, A &, int)

    {

        unwrapper<F>::unwrap(f, 0)();

    }

    template<class F, class A> void operator()(type<void>, F const & f, A &, int) const

    {

        unwrapper<F const>::unwrap(f, 0)();

    }

    template<class V> void accept(V &) const

    {

    }

    bool operator==(list0 const &) const

    {

        return true;

    }

};

template< class A1 > class list1: private storage1< A1 >

{

private:

    typedef storage1< A1 > base_type;

public:

    explicit list1( A1 a1 ): base_type( a1 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }

    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }

    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)

    {

        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[base_type::a1_]);

    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)

    {

        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[base_type::a1_]);

    }

    template<class V> void accept(V & v) const

    {

        base_type::accept(v);

    }

    bool operator==(list1 const & rhs) const

    {

        return ref_compare(base_type::a1_, rhs.a1_, 0);

    }

};

template< class A1, class A2 > class list2: private storage2< A1, A2 >

{

private:

    typedef storage2< A1, A2 > base_type;

public:

    list2( A1 a1, A2 a2 ): base_type( a1, 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 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(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)

    {

        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[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[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[base_type::a1_], a[base_type::a2_]);

    }

    template<class V> void accept(V & v) const

    {

        base_type::accept(v);

    }

    bool operator==(list2 const & rhs) const

    {

        return ref_compare(base_type::a1_, rhs.a1_, 0) && ref_compare(base_type::a2_, rhs.a2_, 0);

    }

};

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 ): base_type( a1, a2, 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 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(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)

    {

        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[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[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[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);

    }

    template<class V> void accept(V & v) const

    {

        base_type::accept(v);

    }

    bool operator==(list3 const & rhs) const

    {

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

    }

};

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 ): base_type( a1, a2, a3, 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 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(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)

    {

        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[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[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[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);

    }

    template<class V> void accept(V & v) const

    {

        base_type::accept(v);

    }

    bool operator==(list4 const & rhs) const

    {

        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 ) &&

            ref_compare( base_type::a4_, rhs.a4_, 0 );

    }

};

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 ): base_type( a1, a2, a3, a4, 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 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(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)

    {

        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[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[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[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

    {

        base_type::accept(v);

    }

    bool operator==(list5 const & rhs) const

    {

        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 ) &&

            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&

            ref_compare( base_type::a5_, rhs.a5_, 0 );

    }

};

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 ): base_type( a1, a2, a3, a4, a5, 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 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(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)

    {

        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[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[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[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

    {

        base_type::accept(v);

    }

    bool operator==(list6 const & rhs) const

    {

        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 ) &&

            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&

            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&

            ref_compare( base_type::a6_, rhs.a6_, 0 );

    }

};

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 ): base_type( a1, a2, a3, a4, a5, a6, 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 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(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)

    {

        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[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[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[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

    {

        base_type::accept(v);

    }

    bool operator==(list7 const & rhs) const

    {

        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 ) &&

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

    }

};

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 ): base_type( a1, a2, a3, a4, a5, a6, a7, 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 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(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)

    {

        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[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[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[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

    {

        base_type::accept(v);

    }

    bool operator==(list8 const & rhs) const

    {

        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 ) &&

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

    }

};

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 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8, 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 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(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)

    {

        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[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[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[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

    {

        base_type::accept(v);

    }

    bool operator==(list9 const & rhs) const

    {

        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 ) &&

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

    }

};

// bind_t

#ifndef BOOST_NO_VOID_RETURNS

template<class R, class F, class L> class bind_t

{

public:

    typedef bind_t this_type;

    bind_t(F f, L const & l): f_(f), l_(l) {}

#define BOOST_BIND_RETURN return

#include <boost/bind/bind_template.hpp>

#undef BOOST_BIND_RETURN

};

#else

template<class R> struct bind_t_generator

{

template<class F, class L> class implementation

{

public:

    typedef implementation this_type;

    implementation(F f, L const & l): f_(f), l_(l) {}

#define BOOST_BIND_RETURN return

#include <boost/bind/bind_template.hpp>

#undef BOOST_BIND_RETURN

};

};

template<> struct bind_t_generator<void>

{

template<class F, class L> class implementation

{

private:

    typedef void R;

public:

    typedef implementation this_type;

    implementation(F f, L const & l): f_(f), l_(l) {}

#define BOOST_BIND_RETURN

#include <boost/bind/bind_template.hpp>

#undef BOOST_BIND_RETURN

};

};

template<class R2, class F, class L> class bind_t: public bind_t_generator<R2>::BOOST_NESTED_TEMPLATE implementation<F, L>

{

public:

    bind_t(F f, L const & l): bind_t_generator<R2>::BOOST_NESTED_TEMPLATE implementation<F, L>(f, l) {}

};

#endif

// function_equal

#ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP

// put overloads in _bi, rely on ADL

# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

template<class R, class F, class L> bool function_equal( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b )

{

    return a.compare(b);

}

# else

template<class R, class F, class L> bool function_equal_impl( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b, int )

{

    return a.compare(b);

}

# endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

#else // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP

// put overloads in boost

} // namespace _bi

# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

template<class R, class F, class L> bool function_equal( _bi::bind_t<R, F, L> const & a, _bi::bind_t<R, F, L> const & b )

{

    return a.compare(b);

}

# else

template<class R, class F, class L> bool function_equal_impl( _bi::bind_t<R, F, L> const & a, _bi::bind_t<R, F, L> const & b, int )

{

    return a.compare(b);

}

# endif // #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

namespace _bi

{

#endif // BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP

// add_value

#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || (__SUNPRO_CC >= 0x530)

template<class T> struct add_value

{

    typedef _bi::value<T> type;

};

template<class T> struct add_value< value<T> >

{

    typedef _bi::value<T> type;

};

template<class T> struct add_value< reference_wrapper<T> >

{

    typedef reference_wrapper<T> type;

};

template<int I> struct add_value< arg<I> >

{

    typedef boost::arg<I> type;

};

template<int I> struct add_value< arg<I> (*) () >

{

    typedef boost::arg<I> (*type) ();

};

template<class R, class F, class L> struct add_value< bind_t<R, F, L> >

{

    typedef bind_t<R, F, L> type;

};

#else

template<int I> struct _avt_0;

template<> struct _avt_0<1>

{

    template<class T> struct inner

    {

        typedef T type;

    };

};

template<> struct _avt_0<2>

{

    template<class T> struct inner

    {

        typedef value<T> type;

    };

};

typedef char (&_avt_r1) [1];

typedef char (&_avt_r2) [2];

template<class T> _avt_r1 _avt_f(value<T>);

template<class T> _avt_r1 _avt_f(reference_wrapper<T>);

template<int I> _avt_r1 _avt_f(arg<I>);

template<int I> _avt_r1 _avt_f(arg<I> (*) ());

template<class R, class F, class L> _avt_r1 _avt_f(bind_t<R, F, L>);