#include <vector>

using std::vector;

template<class T>
class Matrix{
public:    
    Matrix(const vector<vector<T> >& src){
        sz=0;
        rc=src.size();
        for(size_t i=0; i<src.size(); ++i)
            sz+=src[i].size();
        r = new T*[src.size()+1];
        *r = new T[sz];        
        for(size_t i=0; i<src.size(); ++i){
            r[i+1] = r[i]+src[i].size();
            for(size_t j=0; j<src[i].size(); ++j)
                r[i][j]=src[i][j];                         
        }        
    }

    T* operator[](size_t i)const{
        return r[i];
    }
    size_t row_size(size_t i)const{
        return r[i+1]-r[i];
    }
    size_t rows_count()const{
        return rc;
    }
    size_t size() const{
        return sz;
    }
    ~Matrix(){
        delete *r;
        delete r;
    }
private:
    size_t sz,
        rc;
    T **r;
};

template<class T>
class infinite_row_iterator: public std::iterator<std::random_access_iterator_tag,T>{
    T *cur, *end;    
    typedef infinite_row_iterator<T> My_type;
public:
    infinite_row_iterator(T* cur_, T* end_):cur(cur_), end(end_){}
    T operator*()const {return cur<end?*cur:0;}
    My_type& operator++(){
        ++cur;
        return *this;
    }
    My_type operator++(int){ 
        My_type prev=*this;
        ++(*this);
        return prev;
    }
    My_type& operator--(){
        --cur;
        return *this;
    }
    My_type operator--(int){ 
        My_type prev=*this;
        --(*this);
        return prev;
    }
    My_type operator+(size_t n)const{
        My_type it=*this;
        it.cur+=n;
        return it;
    }
    My_type operator-(size_t n)const{
        My_type it=*this;
        it.cur-=n;
        return it;
    }
    ptrdiff_t operator-(const My_type& it)const{
        return cur - it.cur;
    }

    bool operator==(const My_type& it)const {return end==it.end && cur==it.cur;}
    bool operator!=(const My_type& it)const {return !(*this == it);}
    bool operator< (const My_type& it)const {return end==it.end && cur<it.cur;}    
    bool operator> (const My_type& it)const {return it<*this;}
    bool operator<=(const My_type& it)const {return !(it<*this);}
    bool operator>=(const My_type& it)const {return !(*this<it);}
};