#include <iostream>
#include <string>
#include <vector>
using namespace std;
template<typename T>
class Polynomial {
private:
    vector<T> coefficients;
    void Remove_zeros() {
        while(coefficients.size() && coefficients.back() == T(0)) {
            coefficients.pop_back();
        }
        if (coefficients.empty()) {
            coefficients = {T()};
        }
    }
public:
    Polynomial(const std::vector<T>& v) : coefficients(v) {
        Remove_zeros();
    }
    Polynomial(const T& c = T()) {
        coefficients = {c};
        Remove_zeros();
    }
    template<typename Iter>
    Polynomial(Iter first, Iter last) {
        coefficients = vector<T>(first, last);
        Remove_zeros();
    }
    bool operator == (const Polynomial<T>& other) const {
        return coefficients == other.coefficients;
    }
    bool operator != (const Polynomial<T>& other) const {
        return !(coefficients == other.coefficients);
    }
    Polynomial operator += (const Polynomial<T>& other) {
        if (coefficients.size() < other.coefficients.size()) {
            coefficients.resize(other.coefficients.size());
        }
        for (size_t i = 0; i < other.coefficients.size(); ++i) {
            coefficients[i] += other.coefficients[i];
        }
        Remove_zeros();
        return *this;
    }
    Polynomial& operator += (const T& scalar) {
        coefficients[0] += scalar;
        return *this;
    }
    Polynomial operator -= (const Polynomial<T>& other) {
        if (coefficients.size() < other.coefficients.size()) {
            coefficients.resize(other.coefficients.size());
        }
        for (size_t i = 0; i < other.coefficients.size(); ++i) {
            coefficients[i] -= other.coefficients[i];
        }
        Remove_zeros();
        return *this;
    }
    Polynomial& operator -= (const T& scalar) {
        coefficients[0] -= scalar;
        return *this;
    }
    Polynomial operator *= (const T& scalar) {
        for (size_t i = 0; i < coefficients.size(); ++i) {
            coefficients[i] *= scalar;
        }
        Remove_zeros();
        return *this;
    }
    Polynomial operator *= (const Polynomial<T>& other) {
        std::vector<T> new_C(coefficients.size() + other.coefficients.size() + 1);
        for (size_t i = 0; i <= coefficients.size(); ++i) {
            for (size_t j = 0; j <= other.coefficients.size(); ++j) {
                new_C[i + j] += coefficients[i] * other.coefficients[j];
            }
        }
        coefficients = new_C;
        Remove_zeros();
        return *this;
    }
    const T operator [](size_t degree) const {
        if (degree > coefficients.size() - 1) {
            return T(0);
        }
        return coefficients[degree];
    }
    int Degree() const {
        if (coefficients.size() == 1 && coefficients[0] == T()) {
            return -1;
        }
        return coefficients.size() - 1;
    }
    T operator () (const T& x) const {
        T deg = T(1);
        T result = T(0);
        for (size_t i = 0; i < coefficients.size(); ++i) {
            result += coefficients[i] * deg;
            deg *= x;
        }
        return result;
    }
    typename vector<T>::const_iterator begin() const {
        return coefficients.begin();
    }

    typename vector<T>::const_iterator end() const {
        return coefficients.end();
    }
    friend ostream& operator << (std::ostream& out, const Polynomial<T>& p);
};
template<typename T>
ostream& operator << (ostream& out, const Polynomial<T>& a) {
    if (a.Degree() == -1) {
        return out << "0";
    }
    for (int i = a.coefficients.size() - 1; i >= 0; --i) {
        if (a[i] != T(0)) {
            if (a[i] > T(0) && i != a.coefficients.size() - 1) {
                out << "+";
            }
            if (i == 0) {
                out << a[i];
            } else if (a[i] == T(-1)) {
                out << "-";
            } else if (a[i] != T(1)) {
                out << a[i] << "*";
            }
            if (i > 0) {
                out << "x";
                if (i > 1) {
                    out << "^" << i;
                }
            }
        }
    }
    return out;
}
template<typename T>
bool operator == (const Polynomial<T>& a, const T& scalar) {
    return (a == Polynomial<T>(scalar));
}
template<typename T>
bool operator == (const T& scalar, const Polynomial<T>& a) {
    return (a == Polynomial<T>(scalar));
}
template<typename T>
bool operator != (const Polynomial<T>& a, const T& scalar) {
    return !(a == scalar);
}
template<typename T>
bool operator != (const Polynomial<T>& a, const Polynomial<T>& b) {
    return !(a == b);
}
template<typename T>
bool operator != (const T& scalar, const Polynomial<T>& a) {
    return !(a == scalar);
}
template<typename T>
Polynomial<T> operator + (const Polynomial<T>& a, const Polynomial<T>& b) {
    auto k = a;
    return k += b;
}
template<typename T>
Polynomial<T> operator + (const T& scalar, const Polynomial<T>& a) {
    auto k = a;
    return k += scalar;
}
template<typename T>
Polynomial<T> operator - (const Polynomial<T>& a, const Polynomial<T>& b) {
    auto k = a;
    return k -= b;
}
template<typename T>
Polynomial<T> operator - (const T& scalar, const Polynomial<T>& a) {
    auto k = a;
    return k -= scalar;
}
template<typename T>
Polynomial<T> operator * (const T& scalar, const Polynomial<T>& a) {
    auto k = a;
    return k *= scalar;
}
template<typename T>
Polynomial<T> operator * (const Polynomial<T>& a, const Polynomial<T>& b) {
    auto k = a;
    return k *= b;
}
int main() {
    vector<int> d, f;
    d.resize(5);
    f.resize(7);
    for (size_t i = 0; i < 5; ++i) {
        cin >> d[i];
    }
    for (size_t i = 0; i < 7; ++i) {
        cin >> f[i];
    }
}