---

#include <iostream>
#include <cmath>
#include <stdexcept>

const double EPS = 1e-9;

class VECTOR2 {
protected:
    double x, y;
public:
    // Конструкторы
    VECTOR2(double x_ = 0.0, double y_ = 0.0) : x(x_), y(y_) {}

    // Оператор присваивания
    VECTOR2& operator=(const VECTOR2& other) {
        if (this != &other) { // Проверка на самоприсваивание
            x = other.x;
            y = other.y;
        }
        return *this;
    }

    // Вывод координат
    virtual void display() const {
        std::cout << "(" << x << ", " << y << ")";
    }

    // Операции сложения и вычитания
    VECTOR2 operator+(const VECTOR2& other) const {
        return VECTOR2(x + other.x, y + other.y);
    }
    VECTOR2 operator-(const VECTOR2& other) const {
        return VECTOR2(x - other.x, y - other.y);
    }

    // Умножение на число (вектор * число)
    VECTOR2 operator*(double k) const {
        return VECTOR2(x * k, y * k);
    }
    
    // Деление на число
    VECTOR2 operator/(double k) const {
        if (std::fabs(k) < EPS) throw std::runtime_error("Division by zero");
        return VECTOR2(x / k, y / k);
    }

    // Скалярное произведение (вектор * вектор)
    double operator*(const VECTOR2& other) const {
        return x * other.x + y * other.y;
    }

    // Сравнение
    bool operator==(const VECTOR2& other) const {
        return (std::fabs(x - other.x) < EPS) && (std::fabs(y - other.y) < EPS);
    }

    // Статический метод: c = k*a + m*b
    static VECTOR2 combine(double k, const VECTOR2& a, double m, const VECTOR2& b) {
        return a * k + b * m; // использует operator*(double)
    }

    // Доступ к компонентам (при необходимости)
    double getX() const { return x; }
    double getY() const { return y; }

    // Дружественная функция для поддержания записи: double * VECTOR2
    friend VECTOR2 operator*(double k, const VECTOR2& v) {
        return v * k;
    }
};

class VECTOR3 : public VECTOR2 {
private:
    double z;
public:
    // Конструкторы
    VECTOR3(double x_ = 0.0, double y_ = 0.0, double z_ = 0.0)
        : VECTOR2(x_, y_), z(z_) {}

    // Оператор присваивания
    VECTOR3& operator=(const VECTOR3& other) {
        if (this != &other) { // Проверка на самоприсваивание
            VECTOR2::operator=(other); // Вызов оператора присваивания базового класса
            z = other.z;
        }
        return *this;
    }

    // Переопределение display
    void display() const override {
        std::cout << "(" << x << ", " << y << ", " << z << ")";
    }

    // Операции для 3D (возвращают VECTOR3)
    VECTOR3 operator+(const VECTOR3& other) const {
        return VECTOR3(x + other.x, y + other.y, z + other.z);
    }
    VECTOR3 operator-(const VECTOR3& other) const {
        return VECTOR3(x - other.x, y - other.y, z - other.z);
    }

    // Умножение на число (вектор * число)
    VECTOR3 operator*(double k) const {
        return VECTOR3(x * k, y * k, z * k);
    }
    
    VECTOR3 operator/(double k) const {
        if (std::fabs(k) < EPS) throw std::runtime_error("Division by zero");
        return VECTOR3(x / k, y / k, z / k);
    }

    // Скалярное произведение (вектор * вектор) в 3D
    double operator*(const VECTOR3& other) const {
        return x * other.x + y * other.y + z * other.z;
    }

    bool operator==(const VECTOR3& other) const {
        return (std::fabs(x - other.x) < EPS) &&
               (std::fabs(y - other.y) < EPS) &&
               (std::fabs(z - other.z) < EPS);
    }

    static VECTOR3 combine(double k, const VECTOR3& a, double m, const VECTOR3& b) {
        return a * k + b * m;
    }

    friend VECTOR3 operator*(double k, const VECTOR3& v) {
        return v * k;
    }

    double getZ() const { return z; }
};

// Пример использования
int main() {
    VECTOR2 v1(1.0, 2.0);
    VECTOR2 v2(3.0, 4.0);
    
    v1.display(); std::cout << std::endl;
    v2.display(); std::cout << std::endl;

    VECTOR2 v3 = v1 + v2;
    v3.display(); std::cout << std::endl;

    VECTOR3 v4(1.0, 2.0, 3.0);
    VECTOR3 v5(4.0, 5.0, 6.0);

    v4.display(); std::cout << std::endl;
    v5.display(); std::cout << std::endl;

    VECTOR3 v6 = v4 + v5;
    v6.display(); std::cout << std::endl;

    return 0;
}