#ifndef BOOST_PP_IS_ITERATING

#ifndef __RANGE_CONCATENATOR_PP_TPL_HPP
#define __RANGE_CONCATENATOR_PP_TPL_HPP

#include <cstddef>
#include <iterator>
#include <stdexcept>
#include <boost/preprocessor/control/if.hpp>
#include <boost/preprocessor/comparison/greater.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/arithmetic/add.hpp>
#include <boost/preprocessor/repetition/enum.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/preprocessor/limits.hpp>
#include <boost/preprocessor/tuple/elem.hpp>
#include <boost/preprocessor/iteration/iterate.hpp>
#include <boost/iterator/iterator_traits.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/range/size.hpp>
#include <boost/range/iterator.hpp>
#include <boost/range/value_type.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/type_traits.hpp>
#include <boost/variant.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/fold.hpp>
#include <boost/mpl/at.hpp>
#include <boost/mpl/or.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/size.hpp>
#include <boost/mpl/lambda.hpp>
#include <boost/mpl/assert.hpp>

#define BOOST_PP_ITERATION_PARAMS_1 (3, (1, 10, "range_concatenator_pp_tpl.hpp"))

template<typename TMseq_,
    typename Tval_ = typename ::boost::range_value<
            typename ::boost::mpl::at_c< TMseq_, 0 >::type >::type,
    long TMsize_ = boost::mpl::size<TMseq_>::value >
struct range_concatenator
{
};


#include BOOST_PP_ITERATE()

#endif /* __RANGE_CONCATENATOR_PP_TPL_HPP */
#else
    

#define RANGE_CONCATENATOR_MPL_ENUM_TPL(__z__, __n__, __d__) \
    typename ::boost::mpl::at_c<__d__, __n__>::type&

#define RANGE_CONCATENATOR_MPL_ENUM_ITERATOR_TPL(__z__, __n__, __d__) \
    typename ::boost::range_iterator< typename ::boost::mpl::at_c<__d__, __n__>::type >::type

#define RANGE_CONCATENATOR_MPL_ENUM_CONST_ITERATOR_TPL(__z__, __n__, __d__) \
    typename ::boost::range_iterator< const typename ::boost::mpl::at_c<__d__, __n__>::type >::type

#define RANGE_CONCATENATOR_RANGE_TUPLE_SIZE_SUM_TPL(__z__, __n__, __d__) \
    BOOST_PP_IF(BOOST_PP_GREATER(__n__, 0), +, ) ::boost::size( range<__n__>() )

#define RANGE_CONCATENATOR_RANGE_TUPLE_LOOKUP_TPL(__z__, __n__, __d__) \
    if ( __d__ >= ::boost::size( range<__n__>() ) ) \
        __d__ -=  ::boost::size( range<__n__>() ); \
    else \
        return *offsetting( ::boost::begin( range<__n__>() ), __d__ );

#define RANGE_CONCATENATOR_RANGE_SELECT_TPL(__z__, __n__, __d__) \
    case __n__:\
        return __d__( range<__n__>() );

#define RANGE_CONCATENATOR_RANGE_SELECT_ITER_VARIANT_TPL(__z__, __n__, __d__) \
    case __n__:\
        return *(::boost::get< typename ::boost::mpl::at_c< \
                BOOST_PP_TUPLE_ELEM( 2, 0, __d__ ), __n__ >::type >( \
                BOOST_PP_TUPLE_ELEM( 2, 1, __d__ ) ) );

#define RANGE_CONCATENATOR_RANGE_SELECT_ITER_VARIANT_DIFF_TPL(__z__, __n__, __d__) \
    case __n__:\
        { \
            typedef typename ::boost::mpl::at_c< \
                    BOOST_PP_TUPLE_ELEM( 3, 0, __d__ ), __n__ >::type type; \
            return calc_distance( ::boost::get< type >( \
                        BOOST_PP_TUPLE_ELEM( 3, 1, __d__ ) ), \
                    ::boost::get< type >( \
                        BOOST_PP_TUPLE_ELEM( 3, 2, __d__ ) ) ); \
        }

#define RANGE_CONCATENATOR_RANGE_SELECT_ITER_VARIANT_ADD_TPL(__z__, __n__, __d__) \
    case __n__:\
        return offsetting( ::boost::get< typename ::boost::mpl::at_c< \
                BOOST_PP_TUPLE_ELEM( 3, 0, __d__ ), __n__ >::type>( \
                    BOOST_PP_TUPLE_ELEM( 3, 1, __d__ ) ), \
                BOOST_PP_TUPLE_ELEM( 3, 2, __d__ ) ); \

#define RANGE_CONCATENATOR_RANGE_SELECT_ITER_VARIANT_DEREF_TPL(__z__, __n__, __d__) \
    case __n__:\
        return *offsetting( ::boost::get< typename ::boost::mpl::at_c< \
                BOOST_PP_TUPLE_ELEM( 3, 0, __d__ ), __n__ >::type>( \
                    BOOST_PP_TUPLE_ELEM( 3, 1, __d__ ) ), \
                BOOST_PP_TUPLE_ELEM( 3, 2, __d__ ) ); \

#define RANGE_CONCATENATOR_RANGE_SELECT_ITER_VARIANT_UNARY_OP_TPL(__z__, __n__, __d__) \
    case __n__:\
        BOOST_PP_TUPLE_ELEM( 3, 2, __d__ ) \
        ::boost::get< typename ::boost::mpl::at_c< \
                BOOST_PP_TUPLE_ELEM( 3, 0, __d__ ), __n__ >::type>( \
                    BOOST_PP_TUPLE_ELEM( 3, 1, __d__ ) ); \
        break;

template< typename TMseq_, typename Tval_ >
class range_concatenator< TMseq_, Tval_, BOOST_PP_ITERATION() >
{
private:
    template< typename T1_, typename T2_ >
    struct whether_value_type_is_same
    {
        typedef ::boost::mpl::and_<
                ::boost::is_same<
                    typename ::boost::range_value< T2_ >::type,
                    typename ::boost::range_value<
                        typename ::boost::mpl::at_c< TMseq_, 0 >::type
                        >::type >,
                T1_ > type;
    };

    BOOST_MPL_ASSERT(( ::boost::mpl::fold< TMseq_, ::boost::mpl::true_,
            ::boost::mpl::quote2< whether_value_type_is_same > > ));

    template< typename Titer_, typename TiterCat_ >
    class offsetter
    {
    public:
        offsetter( const Titer_& iter ): iter_( iter ) {}

        Titer_ operator()(
            typename ::boost::iterator_difference< Titer_ >::type offset )
        {
            Titer_ retval( iter_ );
            while ( offset > 0 )
            {
                --offset;
                ++retval;
            }
            while ( offset < 0 )
            {
                ++offset;
                --retval;
            }
            return retval;
        }

    private:
        Titer_ iter_;
    };

    template<typename Titer_>
    class offsetter<Titer_, ::std::random_access_iterator_tag >
    {
    public:
        offsetter( const Titer_& iter ): iter_( iter ) {}

        Titer_ operator()(
            typename ::boost::iterator_difference< Titer_ >::type offset )
        {
            return iter_ + offset;
        }

    private:
        Titer_ iter_;
    };


    template<typename Titer_>
    static Titer_ offsetting( const Titer_& iter,
            typename ::boost::iterator_difference< Titer_ >::type offset )
    {
        return offsetter< Titer_,
            typename ::boost::iterator_category< Titer_ >::type >( iter )(
                offset );
    }

    template< typename Titer_, typename TiterCat_ >
    class distance_calculator
    {
    public:
        distance_calculator( const Titer_& iter ): iter_( iter ) {}

        typename ::boost::iterator_difference< Titer_ >::type operator()(
                const Titer_& that )
        {
            typename Titer_::difference_type retval( 0 );
            Titer_ f( that ), b( that );
            for ( ;; )
            {
                if ( f == iter_ )
                {
                    retval = -retval;
                    break;
                }
                else if ( b == iter_ )
                {
                    break;
                }
                ++f, --b;
                ++retval;
            }

            return retval;
        }

    private:
        Titer_ iter_;
    };

    template<typename Titer_>
    class distance_calculator<Titer_, ::std::random_access_iterator_tag >
    {
    public:
        distance_calculator( const Titer_& iter ): iter_( iter ) {}

        typename ::boost::iterator_difference< Titer_ >::type operator()(
                const Titer_& that )
        {
            return iter_ - that;
        }

    private:
        Titer_ iter_;
    };

    template<typename Titer_>
    static typename ::boost::iterator_difference< Titer_ >::type
    calc_distance( const Titer_& lhs, const Titer_& rhs )
    {
        return distance_calculator< Titer_, typename boost::iterator_category< Titer_ >::type >( lhs )( rhs );
    }

public:
    typedef range_concatenator self_type;
    typedef TMseq_ range_type_list_type;
    typedef typename ::boost::mpl::if_<
            ::boost::is_same<
                typename ::boost::mpl::at_c< TMseq_, 0 >::type,
                Tval_>, Tval_&, Tval_>::type return_value_type;
    typedef Tval_ value_type;
    typedef value_type& reference;
    typedef value_type* pointer;
    typedef ::std::size_t size_type;
    typedef ::std::ptrdiff_t difference_type;
    typedef ::boost::tuple<
            BOOST_PP_ENUM(
                BOOST_PP_ITERATION(),
                RANGE_CONCATENATOR_MPL_ENUM_TPL,
                range_type_list_type
            )
        > range_list_type;
    typedef ::boost::variant<
            BOOST_PP_ENUM(
                BOOST_PP_ITERATION(),
                RANGE_CONCATENATOR_MPL_ENUM_TPL,
                range_type_list_type
            )
        > range_variant_type;
    typedef ::boost::variant<
            BOOST_PP_ENUM(
                BOOST_PP_ITERATION(),
                RANGE_CONCATENATOR_MPL_ENUM_ITERATOR_TPL,
                range_type_list_type
            )
        > iterator_variant_type;
    typedef ::boost::variant<
            BOOST_PP_ENUM(
                BOOST_PP_ITERATION(),
                RANGE_CONCATENATOR_MPL_ENUM_CONST_ITERATOR_TPL,
                range_type_list_type
            )
        > const_iterator_variant_type;
    typedef ::boost::mpl::vector<
            BOOST_PP_ENUM(
                BOOST_PP_ITERATION(),
                RANGE_CONCATENATOR_MPL_ENUM_ITERATOR_TPL,
                range_type_list_type
            )
        > iterator_type_list_type;
    typedef ::boost::mpl::vector<
            BOOST_PP_ENUM(
                BOOST_PP_ITERATION(),
                RANGE_CONCATENATOR_MPL_ENUM_CONST_ITERATOR_TPL,
                range_type_list_type
            )
        > const_iterator_type_list_type;

protected:
    template< typename Tiv_, typename Til_ >
    class iterator_info
    {
    public:
        typedef ::std::ptrdiff_t difference_type;

    public:
        iterator_info( range_concatenator& impl,
                ::std::size_t range_idx, Tiv_ iter )
            : impl_( impl ), range_idx_( range_idx ), iter_( iter )
        {
        }

        iterator_info( range_concatenator& impl,
                ::std::size_t range_idx )
            : impl_( impl ), range_idx_( range_idx ),
              iter_( impl.begin( range_idx ) )
        {
        }

        bool operator<( const iterator_info& rhs ) const
        {
            return ( range_idx_ < rhs.range_idx_ )
                || ( range_idx_ == rhs.range_idx_ &&
                    iter_ < rhs.iter_ );
        }

        bool operator>( const iterator_info& rhs ) const
        {
            return ( range_idx_ > rhs.range_idx_ )
                || ( range_idx_ == rhs.range_idx_ &&
                    iter_ > rhs.iter_ );
        }

        bool operator==( const iterator_info& rhs ) const
        {
            return ( range_idx_ == rhs.range_idx_ && iter_ == rhs.iter_ );
        }

        bool operator!=( const iterator_info& rhs ) const
        {
            return !operator==( rhs );
        }

        bool operator>=( const iterator_info& rhs ) const
        {
            return !operator<( rhs );
        }

        bool operator<=( const iterator_info& rhs ) const
        {
            return !operator>( rhs );
        }

        return_value_type operator*() const
        {
            switch ( range_idx_ ) {
                BOOST_PP_REPEAT(
                    BOOST_PP_ITERATION(),
                    RANGE_CONCATENATOR_RANGE_SELECT_ITER_VARIANT_TPL,
                    ( Til_, iter_ )
                )
            }
        }

        return_value_type operator[]( difference_type off ) const
        {
            return *(*this + off);
        }

        static difference_type distance(
                ::std::size_t range_idx,
                const Tiv_& lhs, const Tiv_& rhs )
        {
            switch ( range_idx ) {
                BOOST_PP_REPEAT(
                    BOOST_PP_ITERATION(),
                    RANGE_CONCATENATOR_RANGE_SELECT_ITER_VARIANT_DIFF_TPL,
                    ( Til_, lhs, rhs )
                )
            }
        } 

        static Tiv_ add(
                ::std::size_t range_idx,
                const Tiv_& lhs, difference_type rhs )
        {
            switch ( range_idx ) {
                BOOST_PP_REPEAT(
                    BOOST_PP_ITERATION(),
                    RANGE_CONCATENATOR_RANGE_SELECT_ITER_VARIANT_ADD_TPL,
                    ( Til_, lhs, rhs )
                )
            }
        } 

        static void increment( ::std::size_t range_idx, Tiv_& iter )
        {
            switch ( range_idx ) {
                BOOST_PP_REPEAT(
                    BOOST_PP_ITERATION(),
                    RANGE_CONCATENATOR_RANGE_SELECT_ITER_VARIANT_UNARY_OP_TPL,
                    ( Til_, iter, ++ )
                )
            }
        }

        static void decrement( ::std::size_t range_idx, Tiv_& iter )
        {
            switch ( range_idx ) {
                BOOST_PP_REPEAT(
                    BOOST_PP_ITERATION(),
                    RANGE_CONCATENATOR_RANGE_SELECT_ITER_VARIANT_UNARY_OP_TPL,
                    ( Til_, iter, -- )
                )
            }
        }

        iterator_info operator+( difference_type off ) const
        {
            difference_type o( off );
            iterator_info retval( *this );
            Tiv_ begin( impl_.begin( retval.range_idx_ ) );
            Tiv_ end( impl_.end( retval.range_idx_ ) );

            for (;;)
            {
                retval.iter_ = add( retval.range_idx_, retval.iter_, o );
                if ( distance( retval.range_idx_, retval.iter_, begin ) < 0 )
                {
                    if ( retval.range_idx_ == 0 )
                    {
                        throw ::std::out_of_range("offset out of range: "
                                + boost::lexical_cast< ::std::string>( off ) );
                    }
                    o = distance( retval.range_idx_, retval.iter_, begin );
                    --retval.range_idx_;
                    begin = impl_.begin( retval.range_idx_ );
                    end = impl_.end( retval.range_idx_ );
                    retval.iter_ = end;
                }
                else if ( distance( retval.range_idx_, retval.iter_, end ) >= 0 )
                {
                    if ( retval.range_idx_ >= impl_.range_count() )
                    {
                        throw ::std::out_of_range("offset out of range: "
                                + boost::lexical_cast< ::std::string>( off ) );
                    }
                    o = distance( retval.range_idx_, retval.iter_, end );
                    ++retval.range_idx_;
                    begin = impl_.begin( retval.range_idx_ );
                    end = impl_.end( retval.range_idx_ );
                    retval.iter_ = begin;
                }
                else
                {
                    break;
                }
            }
            return retval;
        }

        difference_type operator-( const iterator_info& rhs ) const
        {
            difference_type retval = 0;
            Tiv_ i( iter_ );
            ::std::size_t ridx( range_idx_ );
            Tiv_ begin( impl_.begin( ridx ) );
            Tiv_ end( impl_.end( ridx ) );

            if ( rhs.range_idx_ > range_idx_ )
            {
                do
                {
                    retval -= distance( ridx, end, i );
                    ++ridx;
                    BOOST_ASSERT( ridx < impl_.range_count() );
                    begin = impl_.begin( ridx );
                    end = impl_.end( ridx );
                    i = begin;
                } while ( rhs.range_idx_ > ridx );
                retval -= rhs.iter_ - i;
            }
            else if ( rhs.range_idx_ < range_idx_ )
            {
                do
                {
                    retval += distance( ridx, i, begin );
                    --ridx;
                    BOOST_ASSERT( ridx >= 0 );
                    begin = impl_.begin( ridx );
                    end = impl_.end( ridx );
                    i = end;
                } while ( rhs.range_idx_ < ridx );
                retval += i - rhs.iter_;
            }
            else
            {
                retval = i - rhs.iter_;
            }
            return retval;
        }
    public:
        range_concatenator& impl_;
        ::std::size_t range_idx_;
        Tiv_ iter_;
    };

public:
    template< typename Tiv_, typename Til_ >
    class iterator_base: public iterator_info< Tiv_, Til_ >
    {
    public:
        typedef iterator_info< Tiv_, Til_ > base_type;
        typedef typename range_concatenator::value_type value_type;
        typedef typename range_concatenator::difference_type difference_type;
        typedef typename range_concatenator::pointer pointer;
        typedef typename range_concatenator::reference reference;
        typedef ::std::bidirectional_iterator_tag iterator_cateory;

    public:
        const iterator_base& operator++()
        {
            increment( base_type::range_idx_, base_type::iter_ );
            if ( distance( base_type::range_idx_, base_type::iter_, end_ ) >= 0 )
            {
                if ( base_type::range_idx_ < base_type::impl_.range_count() - 1 )
                {
                    ++base_type::range_idx_;
                    base_type::iter_ = begin_ = base_type::impl_.begin(
                            base_type::range_idx_ );
                    end_ = base_type::impl_.end( base_type::range_idx_ );
                }
            }

            return *this;
        }

        const iterator_base& operator++(int)
        {
            iterator retval( *this, base_type::iter_ );

            increment( base_type::range_idx_, base_type::iter_ );
            if ( distance( base_type::range_idx_, base_type::iter_, base_type::end_ ) >= 0 )
            {
                if ( base_type::range_idx_ < base_type::impl_.range_count() - 1 )
                {
                    ++base_type::range_idx_;
                    base_type::iter_ = begin_ = base_type::impl_.begin(
                            base_type::range_idx_ );
                    end_ = base_type::impl_.end( base_type::range_idx_ );
                }
            }

            return retval;
        }

        const iterator_base& operator--()
        {
            if ( base_type::iter_ == begin_ )
            {
                if ( base_type::range_idx_ > 0 )
                {
                   --base_type::range_idx_;
                    base_type::iter_ = ( end_ = base_type::impl_.range(
                            base_type::range_idx_ ).end() );
                    begin_ = base_type::impl_.range( base_type::range_idx_ ).begin();
                }
            }

            decrement( base_type::range_idx_, base_type::iter_ );

            return *this;
        }

        const iterator_base& operator--(int)
        {
            iterator retval( *this, base_type::iter_ );

            if ( base_type::iter_ == begin_ )
            {
                if ( base_type::range_idx_ > 0 )
                {
                    --base_type::range_idx_;
                    base_type::iter_ = ( end_ = base_type::impl_.range(
                            base_type::range_idx_ ).end() );
                    begin_ = base_type::impl_.range( base_type::range_idx_ ).begin();
                }
            }

            decrement( base_type::range_idx_, base_type::iter_ );

            return retval;
        }

        reference operator[]( difference_type off )
        {
            if ( distance( base_type::range_idx_, base_type::iter_, begin_ ) + off >= 0 &&
                    distance( base_type::range_idx_, end_, base_type::iter_ ) > off )
            {
                switch ( base_type::range_idx_ ) {
                BOOST_PP_REPEAT(
                    BOOST_PP_ITERATION(),
                    RANGE_CONCATENATOR_RANGE_SELECT_ITER_VARIANT_DEREF_TPL,
                    ( Til_, base_type::iter_, off )
                )
                }
            }
            return base_type::operator[]( off );
        }

    protected:
        iterator_base( const iterator_info< Tiv_, Til_ >& info )
            : base_type( info ),
              begin_( info.impl_.begin( info.range_idx_ ) ),
              end_( info.impl_.end( info.range_idx_ ) ) {}

        iterator_base( const iterator_base& proto, const Tiv_& iter )
            : base_type( proto.impl_, proto.range_idx_, iter ),
              begin_( proto.begin_ ), end_( proto.end_ ) {}

    protected:
        Tiv_ begin_, end_;
    };

    struct iterator: public iterator_base< iterator_variant_type,
            iterator_type_list_type >
    {
        typedef iterator_base< iterator_variant_type,
                iterator_type_list_type > base_type;
        typedef typename base_type::base_type info_type;

        iterator( const info_type& that )
            : base_type( that ) {}
        
        iterator( const info_type& that, const iterator_variant_type& iter )
            : base_type( that, iter ) {}
    };

    friend struct iterator;

    struct const_iterator: public iterator_base< const_iterator_variant_type,
            const_iterator_type_list_type >
    {
        typedef iterator_base< const_iterator_variant_type,
                const_iterator_type_list_type > base_type;
        typedef typename base_type::base_type info_type;

        const_iterator( const info_type& that )
            : base_type( that ) {}
        
        const_iterator( const info_type& that,
                const const_iterator_variant_type& iter )
            : base_type( that, iter ) {}
    };

    friend struct const_iterator;

public:
    range_concatenator( const range_list_type& ranges )
        : ranges_( ranges ) {}

    size_type size() const
    {
        return BOOST_PP_REPEAT(
                BOOST_PP_ITERATION(),
                RANGE_CONCATENATOR_RANGE_TUPLE_SIZE_SUM_TPL,);
    }

    template<long Nidx_>
    typename ::boost::mpl::at_c<range_type_list_type, Nidx_>::type& range()
    {
        return ::boost::get<Nidx_>( ranges_ );
    }

    template<long Nidx_>
    const typename ::boost::mpl::at_c<range_type_list_type, Nidx_>::type&
    range() const
    {
        return ::boost::get<Nidx_>( ranges_ );
    }

    range_variant_type range( ::std::size_t idx )
    {
        switch ( idx ) {
            BOOST_PP_REPEAT(
                BOOST_PP_ITERATION(),
                RANGE_CONCATENATOR_RANGE_SELECT_TPL,
                ::boost::begin
            )
        }
    }

    iterator_variant_type begin( ::std::size_t idx )
    {
        switch ( idx ) {
            BOOST_PP_REPEAT(
                BOOST_PP_ITERATION(),
                RANGE_CONCATENATOR_RANGE_SELECT_TPL,
                ::boost::begin
            )
        }
    }

    const_iterator_variant_type begin( ::std::size_t idx ) const
    {
        switch (idx) {
            BOOST_PP_REPEAT(
                BOOST_PP_ITERATION(),
                RANGE_CONCATENATOR_RANGE_SELECT_TPL,
                ::boost::begin
            )
        }
    }

    iterator_variant_type end( ::std::size_t idx )
    {
        switch ( idx ) {
            BOOST_PP_REPEAT(
                BOOST_PP_ITERATION(),
                RANGE_CONCATENATOR_RANGE_SELECT_TPL,
                ::boost::end
            )
        }
    }

    const_iterator_variant_type end( ::std::size_t idx ) const
    {
        switch (idx) {
            BOOST_PP_REPEAT(
                BOOST_PP_ITERATION(),
                RANGE_CONCATENATOR_RANGE_SELECT_TPL,
                ::boost::end
            )
        }
    }

    iterator begin()
    {
        return iterator( typename iterator::info_type( *this, 0 ) );
    }

    iterator end()
    {
        return iterator(
                typename iterator::info_type( *this, num_ranges_ - 1,
                    ::boost::get< num_ranges_ - 1 >( ranges_ ).end() ) );
    }

    return_value_type at( size_type idx )
    {
        BOOST_PP_REPEAT(
            BOOST_PP_ITERATION(),
            RANGE_CONCATENATOR_RANGE_TUPLE_LOOKUP_TPL,
            idx );
    }

    const return_value_type at( size_type idx ) const
    {
        BOOST_PP_REPEAT(
            BOOST_PP_ITERATION(),
            RANGE_CONCATENATOR_RANGE_TUPLE_LOOKUP_TPL,
            idx );
    }

    static ::std::size_t range_count()
    {
        return num_ranges_;
    }

private:
    range_list_type ranges_;
    static const long num_ranges_ = BOOST_PP_ITERATION();
};

#endif /* BOOST_PP_ITERATING */