#define USE_MPL 1
#define SEQUENCE list
//#define SEQUENCE vector
//#define AT slow_at
#define AT fast_at

#if USE_MPL

#include <cassert>
#include <boost/mpl/list.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/vector/vector50.hpp>
#include <boost/mpl/at.hpp>
#include <boost/mpl/size.hpp>
#include <boost/mpl/push_front.hpp>
using namespace boost;
using namespace mpl;

template <int N>
struct make_list {
    typedef typename push_front<typename make_list<N-1>::type, int_<N> >::type type;
};

template <>
struct make_list<0> {
    typedef SEQUENCE<> type;
};

int const test_length = 100;

typedef make_list<test_length>::type lista;


template <int N, int M>
struct test {
    static int const value =
        at<lista, int_<N> >::type::value
        + test<N+1, M>::value;
};

template <int N>
struct test <N, N> {
    static int const value = 0;
};


int main()
{
    assert(( test<0, test_length>::value == test_length*(test_length+1)/2));
}

#else

#include <cassert>
struct nil;

template <class H, class T>
struct list {
    typedef H head;
    typedef T tail;
};

template <class L, int N>
struct slow_at {
    typedef typename slow_at<typename L::tail, N-1>::type type;
};

template <class L>
struct slow_at <L, 0> {
    typedef typename L::head type;
};

template <int N, class L>
struct drop {
    typedef typename drop<N-1, L>::type::tail type;
};

template <class L>
struct drop <0, L> {
    typedef L type;
};

template <class L, int N>
struct fast_at {
    typedef typename drop<N, L>::type::head type;
};

template <int N>
struct node {
    static int const value = N;
};

template <int N>
struct make_list {
    typedef list<node<N>, typename make_list<N-1>::type> type;
};

template <>
struct make_list<0> {
    typedef nil type;
};

int const test_length = 100;

typedef make_list<test_length>::type lista;

template <int N, int M>
struct test {
    static int const value =
        AT<lista, N>::type::value
        + test<N+1, M>::value;
};

template <int N>
struct test <N, N> {
    static int const value = 0;
};

int main()
{
    assert(( test<0, test_length>::value == test_length*(test_length+1)/2));
}

#endif