#include <iostream>
#include <cmath>

class Complex {
private:
    double re, im;

public:
    Complex()
            : re(.0),
              im(.0) {}

    explicit Complex(double a)
            : re(a),
              im(.0) {}

    Complex(double a, double b)
            : re(a),
              im(b) {}

    double Re() const {
        return re;
    }

    double &Re() {
        return re;
    }

    double Im() const {
        return im;
    }

    double &Im() {
        return im;
    }

    Complex Conj() const {
        return Complex(re, -im);
    }

    Complex operator-() const {
        return Complex(-re, -im);
    }

    Complex operator+() const {
        return Complex(re, im);
    }
};

double abs(const Complex &z) {
    return sqrt(z.Re() * z.Re() + z.Im() * z.Im());
}

Complex operator+(const Complex &one, const Complex &other) {
    return Complex(one.Re() + other.Re(), one.Im() + other.Im());
}

Complex operator+(const Complex &one, double other) {
    return Complex(one.Re() + other, one.Im());
}

Complex operator+(double other, const Complex &one) {
    return Complex(one.Re() + other, one.Im());
}

Complex operator-(const Complex &one, const Complex &other) {
    return Complex(one.Re() - other.Re(), one.Im() - other.Im());
}

Complex operator-(const Complex &one, double other) {
    return Complex(one.Re() - other, one.Im());
}

Complex operator-(double other, const Complex &one) {
    return Complex(other - one.Re(), -one.Im());
}

Complex operator*(const Complex &one, const Complex &other) {
    return Complex(one.Re() * other.Re() - one.Im() * other.Im(),
            one.Re() * other.Im() + one.Im() * other.Re());
}

Complex operator*(const Complex &one, double other) {
    return Complex(one.Re() * other, one.Im() * other);
}

Complex operator*(double other, const Complex &one) {
    return Complex(one.Re() * other, one.Im() * other);
}

Complex operator/(const Complex &one, double other) {
    return Complex(one.Re() / other, one.Im() / other);
}

Complex operator/(const Complex &one, const Complex &other) {
    double denom_abs = abs(other);
    Complex inv = other.Conj() / (denom_abs * denom_abs);
    return one * inv;
}

Complex operator/(double other, const Complex &one) {
    double denom_abs = abs(one);
    Complex inv = one.Conj() / (denom_abs * denom_abs);
    return other * inv;
}

bool operator==(const Complex &one, const Complex &other) {
    return one.Re() == other.Re() && one.Im() == other.Im();
}

bool operator!=(const Complex &one, const Complex &other) {
    return one.Re() != other.Re() || one.Im() != other.Im();
}

std::ostream &operator<<(std::ostream &out, const Complex &z) {
    out << z.Re() << " " << z.Im() << "i";
    return out;
}