#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <iterator>

using namespace std;

template <typename T>
class Polynomial {
private:
    vector<T> polynom;
    int size_p = 0;
public:
    Polynomial(vector<T> pol) {
        this->polynom = pol;
        this->size_p = pol.size();
        this->delete_zeros();
    }

    Polynomial(T object = T()) {
        polynom.push_back(object);
        this->size_p = 1;
    }

    template<typename Iter = typename vector<T>::iterator>
    Polynomial(Iter begin, Iter end) {
        Iter it;
        size_p = 0;
        for (it = begin; it != end; it++) {
            polynom.push_back(*it);
            size_p++;
        }
        this->delete_zeros();
    }

    void delete_zeros() {
        vector<T> result = polynom;
        for (int i = size_p - 1; i > 0; i--) {
            if (result[i] == T(0)) {
                result.pop_back();
                size_p--;
            } else {
                i = -1;
            }
        }
        polynom = result;
    }

    vector<T> get_polynom() const {
        return polynom;
    }

    int get_size() const {
        return size_p;
    }

    vector<T> multiply(vector<T> A, vector<T> B) {
        int m = A.size();
        int n = B.size();
        vector<T> prod;
        for (int i = 0; i < m + n - 1; i++) {
            prod.push_back(T(0));
        }
        for (int i = 0; i< m; i++) {
            for (int j = 0; j < n; j++) {
                prod[i + j] += A[i] * B[j];
            }
        }
        return prod;
    }

    bool operator == (Polynomial<T> pol) const {
        return polynom == pol.get_polynom();
    }

    bool operator != (Polynomial<T> pol) const {
        return polynom != pol.get_polynom();
    }

    void operator += (Polynomial<T> pol) {
        vector<T> preres;
        preres = polynom;
        for (int i = 0; i < size_p; i++) {
            preres[i] += pol.get_polynom()[i];
        }
        for (int i = size_p + 1; i < pol.get_size(); i++) {
            preres.push_back(T(0) + pol.get_polynom()[i]);
        }
        Polynomial<T> result(preres);
        result.delete_zeros();
        this->polynom = result.get_polynom();
        this->size_p = result.get_size();
    }

    void operator += (T pol) {
        polynom[0] += pol;
    }

    Polynomial<T> operator - (Polynomial<T> pol) const {
        vector<T> preres;
        preres = polynom;
        for (int i = 0; i < size_p; i++) {
            preres[i] -= pol.get_polynom()[i];
        }
        for (int i = size_p + 1; i < pol.get_size(); i++) {
            preres.push_back(T(0) - pol.get_polynom()[i]);
        }
        return Polynomial<T>(preres);
    }

    Polynomial<T> operator - (T pol) const {
        vector<T> res = this->get_polynom();
        res[0] -= pol;
        return Polynomial<T>(res);
    }

    void operator -= (Polynomial<T> pol) {
        Polynomial<T> res = this - pol;
        this = res;
    }

    void operator -= (T pol) {
        polynom[0] -= pol;
    }

    void operator *= (Polynomial<T> pol) {
        size_p = size_p + pol.get_size();
        vector<T> result_coeff = multiply(polynom, pol.get_polynom());
        polynom = result_coeff;
        size_p = result_coeff.size();
        this->delete_zeros();
    }

    void operator *= (T pol) {
        for (int i = 0; i < size_p; i++) {
            polynom[i] *= pol;
        }
        this->delete_zeros();
    }

    Polynomial<T> operator + (Polynomial<T> pol) const {
        Polynomial<T> result = *this;
        result += pol;
        return result;
    }

    Polynomial<T> operator + (T pol) const {
        Polynomial<T> r = *this;
        r += pol;
        return r;
    }

    Polynomial<T> operator * (Polynomial<T> pol) const {
        vector<T> preres = this->get_polynom();
        Polynomial<T> result(preres);
        result *= pol;
        return result;
    }

    Polynomial<T> operator * (T pol) const {
        vector<T> preres = this->get_polynom();
        for (int i = 0; i < size_p; i++) {
            preres[i] *= pol;
        }
        Polynomial<T> result(preres);
        return result;
    }

    T operator [](int id) const {
        if (id >= size_p) {
            return T(0);
        } else {
            return polynom[id];
        }
    }

    T operator ()(T id) const {
        if (id == T(0)) {
            return polynom[0];
        } else {
            T x = T(1);
            T result = T(0);
            for (int i = 0; i < size_p; i++) {
                result += x * polynom[i];
                x *= id;
            }
            return result;
        }
    }

    int Degree() const {
        if (size_p == 1 && polynom[0] == 0) {
            return -1;
        } else {
            return size_p - 1;
        }
    }

    template<typename Iter = typename vector<T>::const_iterator>
    Iter begin() const {
        return polynom.begin();
    }

    template<typename Iter = typename vector<T>::const_iterator>
    Iter end() const {
        return polynom.end();
    }

};

template <typename T>
Polynomial<T> operator * (T t, Polynomial<T> pol) {
    return pol * t;
}

template <typename T>
Polynomial<T> operator - (T t, Polynomial<T> pol) {
    return pol - t;
}

template <typename T>
Polynomial<T> operator + (T t, Polynomial<T> pol) {
    return pol + t;
}

class int2 {
private:
    int int1;
public:
    int2(int i) {
        this->int1 = i;
    }

    int2() {
        this->int1 = 1;
    }

    bool operator == (const int2& i) const {
        return int1 == i.get();
    }

    bool operator != (const int2& i) const {
        return int1 != i.get();
    }

    int get() const {
        return this->int1;
    }

    int2 operator + (int2 i1) const {
        int res = this->int1 + i1.get();
        return int2(res);
    }

    void operator += (int2 i1) {
        int1 += i1.get();
    }

    int2 operator - (int2 i1) const {
        int res = this->int1 - i1.get();
        return int2(res);
    }

    void operator -= (int2 i1) {
        int1 -= i1.get();
    }

    int2 operator * (int2 i1) const {
        int res = this->int1 * i1.get();
        return int2(res);
    }

    void operator *= (int2 i1) {
        int1 *= i1.get();
    }

    operator int() {
        return this->int1;
    }


};

void coutVector(vector<int2> re) {
    for (int2 i : re) {
        cout << i.get() << " ";
    }
    cout << endl;
}

int main() {
    /*vector<int2> res = { int2(1), int2(1), int2(1), int2(1) };
    vector<int2> res2 = { int2(2), int2(3), int2(4), int2(5) };
    vector<int2> res3 = { int2(1), int2(1), int2(1), int2(1) };
    Polynomial<int2> p(res);
    Polynomial<int2> p1(res2);
    Polynomial<int2> p3(res);
    coutVector((p - p3).get_polynom());
    coutVector((p - p1).get_polynom());
    coutVector(p3.get_polynom());*/
    /*coutVector((p * p1).get_polynom());
    coutVector((p * int2()).get_polynom());
    cout << p1(int2(0));*/
    vector<int2> result = { int2(1), int2(2), int2(3), int2(4) };
    Polynomial<int2> polynom(result);
    vector<int2> result2 = { int2(3), int2(4), int2(5), int2(6) };
    Polynomial<int2> polynom2(result2);
    vector<int2> r = (polynom * polynom2).get_polynom();
    coutVector(r);
    vector<int2> r1 = (polynom + polynom2).get_polynom();
    coutVector(r1);
    vector<int2> r2 = (polynom - polynom2).get_polynom();
    coutVector(r2);
    polynom += polynom2;
    coutVector(polynom.get_polynom());
    polynom -= polynom2;
    coutVector(polynom.get_polynom());
    polynom *= polynom2;
    coutVector(polynom.get_polynom());
    polynom += int2(1);
    coutVector(polynom.get_polynom());
    polynom -= int2(1);
    coutVector(polynom.get_polynom());
    polynom *= int2(2);
    coutVector(polynom.get_polynom());
    coutVector((polynom + int2(2)).get_polynom());
    coutVector((polynom - int2(2)).get_polynom());
    coutVector((polynom * int2(2)).get_polynom());
    coutVector((int2(2) + polynom).get_polynom());
    coutVector((int2(2) - polynom).get_polynom());
    coutVector((int2(2) * polynom).get_polynom());
    cout << (polynom != polynom2);
}