#include <iostream>
#include <iterator>
#include <vector>

// template <typename T, int N>
// class Vector;

template <typename T, int N>
class ScalarIterator;

template <typename T, int N>
class Sequence
{
private:
    vector<vector<T> > seq;
    vector<T> scal;
    friend class ScalarIterator<T, N>;
public:
    Sequence()
    {
        seq = new vector();
        scal = new vector();
    }

    void set_back(vector<T> x)
    {
        if (n.size() != N) throw "incorrect dimencity";
        if (seq.empty() || seq.size() == 1)
        {
            seq.emplace_back(x);
            return;
        }
        else
        {
            seq.emplace_back(x);
            T s = 0;
            for (int i = 0; i < N; i++)
                s += x[i] * (seq[seq.size()-1])[i];
            scal.emplace_back(s);
        }
    }

    ScalarIterator<T, N> begin();
    ScalarIterator<T, N> end();

    Vector operator[] (int n) {
        return seq[n];
    }

    friend ostream& operator<< (ostream& os, Sequence<T, N>& n)
    {
        for (auto i : n.seq)
            os << i << "\n";
        return os;
    }
};

// template<typename T, int N>
// class Vector
// {
// private:
//     vector<T> v;
// public:
//     Vector(Sequence<T, N> *seq, T scal): ;
//     T operator* (const Vector obj)
//     {
//         T res = 0;
//         for (int i = 0; i < N; i++){
//             res += this->v[i] * obj.v[i];
//         }
//         return res;
//     }
//     bool operator== (const Vector obj)
//     {
//         return this->v == obj.v;
//     }
//     bool operator!= (const Vector obj)
//     {
//         return !(*this == obj);
//     }
//     T operator[] (int i)
//     {
//         return v[i];
//     }
//     const T operator[] (int i) const{
//         return v[i];
//     }
//     friend ostream& operator<< (ostream& os, Vector<T, N>& v)
//     {
//         for (auto i : v.v)
//         {
//             os << i << " ";
//         }
//         os << "\n";
//         return os;
//     }
// };

template <typename T, int N>
class ScalarIterator:
    public iterator<
        bidirectional_iterator_tag,
        int,
        ptrdiff_t,
        Vector<T, N>*,
        Vector<T, N>
    >
{
private:
    Vector<T, N> *vec;
    int scal;
    bool is_default;

    bool is_end() const {
        return scal > 0;
    }

public:
        ScalarIterator(): is_default(true) {}

        ScalarIterator(Vector<T, N> &obj, int scal): vec(&obj), scal(scal), is_default(false) {}

    bool operator== (const     ScalarIterator<T, N> &other) const
    {
        return (is_default && other.is_default) ||
            (is_default && other.is_end()) ||
            (is_end() && other.is_default) ||
            (vec == other.vec && scal == other.scal);
    }

    bool operator!= (const     ScalarIterator<T, N> &other) const
    {
        return !(*this == other);
    }

    Vector<T, D> operator* ()
    {
        if (is_default) throw "not initialized iterator";
        return Vector<T, N>(vec, scal);
    }
};

template<typename T, int N>
ScalarIterator<T, N> Sequence<T, N>::begin()
{
    return ScalarIterator<T, N>(*this);
}

template<typename T, int N>
ScalarIterator<T, N> Sequence<T, N>::end()
{
    T scal = 0;

    return ScalarIterator<T, N>(*this);
}