#include <iterator>
template<class type>
class value_iterator {
public:
typedef size_t difference_type;
typedef type value_type;
typedef const type& reference;
typedef const type* pointer;
typedef std::random_access_iterator_tag iterator_category;
value_iterator() :ptr() {}
value_iterator(difference_type offset, const type& value) :off(offset), ptr(&value) {}
friend bool operator==(const value_iterator& lhs, const value_iterator& rhs) {return lhs.ptr==rhs.ptr && lhs.off==rhs.off;}
friend bool operator!=(const value_iterator& lhs, const value_iterator& rhs) {return lhs.ptr!=rhs.ptr || lhs.off!=rhs.off;}
value_iterator& operator++() {++off; return *this;}
value_iterator operator++(int) {return value_iterator(off++, *ptr);}
value_iterator& operator--() {--off; return *this;}
value_iterator operator--(int) {return value_iterator(off--, *ptr);}
value_iterator& operator+=(difference_type o) {off+=o; return *this;}
friend value_iterator operator+(const value_iterator& it, difference_type o) {return value_iterator(it.off+o, *it.ptr);}
friend value_iterator operator+(difference_type o, const value_iterator& it) {return value_iterator(it.off+o, *it.ptr);}
value_iterator& operator-=(difference_type o) {off-=o; return *this;}
friend value_iterator operator-(const value_iterator& it, difference_type o) {return value_iterator(it.off-o, *it.ptr);}
friend difference_type operator-(value_iterator lhs, value_iterator rhs) {return lhs.off-rhs.off;}
reference operator*() const {return *ptr;}
pointer operator->() const {return ptr;}
reference operator[](difference_type) const {return *ptr;}
friend void swap(value_iterator& lhs, value_iterator& rhs) {std::swap(lhs.ptr, rhs.ptr); std::swap(lhs.off, rhs.off);}
private:
difference_type off;
const type* ptr;
};
template<class type> value_iterator<type> make_value_iterator(size_t count, const type& value) {return value_iterator<type>(count, value);}
template<class type> value_iterator<type> make_value_iterator(const type& value) {return value_iterator<type>(0, value);}
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