#pragma once
 
#include <vector>
 
template<class It>
class IteratorRange {
public:
    IteratorRange(It b, It e) : begin_(b), end_(e), size_(std::distance(b, e)) {}
    typedef It iterator;
    It begin() const {
        return begin_;
    }
 
    It end() const {
        return end_;
    }
 
    std::size_t size() const {
        return size_;
    }
 
private:
    It begin_, end_;
    std::size_t size_;
};
 
template<typename It>
class Slicer {
public:
 
    Slicer(It b, It e, std::size_t size) {
        std::size_t dist = std::distance(b, e);
        std::size_t start = 0;
        std::size_t end = size;
        while (end < dist) {
            this->pages_.push_back(IteratorRange<It>(b + start, b + end));
            start = end ;
            end += size;
        }
        if (end >= dist) {
            end = dist < end ? dist : end;
            this->pages_.push_back(IteratorRange<It>(b + start, b + end));
        }
    }
 
    typename std::vector<IteratorRange<It>>::iterator begin() {
        return pages_.begin();
    }
 
    typename std::vector<IteratorRange<It>>::iterator end() {
        return pages_.end();
    }
 
 
    std::size_t size() {
        return pages_.size();
    }
 
private:
    std::vector<IteratorRange<It>> pages_;
};
 
template<typename C>
Slicer<typename C::iterator> Slice(C &c, std::size_t page_size) {
    return Slicer<typename C::iterator>(c.begin(), c.end(), page_size);
}
 
template<typename C>
Slicer<typename C::const_iterator> Slice(const C &c, std::size_t page_size) {
    return Slicer<typename C::const_iterator>(c.begin(), c.end(), page_size);
}