#include <cmath>
using namespace std;

class Complex {
private:
    double R;
    double I;

public:
    Complex(double Re, double Im) {
        this->R = Re;
        this->I = Im;
    }

    Complex(double Re) {
        this->R = Re;
        this->I = 0;
    }

    double Re() const {
        return R;
    }

    double Im() const {
        return I;
    }

    Complex operator + (const Complex& com) const {
        Complex result(R + com.Re(), I + com.Im());
        return result;
    }

    template <typename num>
    Complex operator + (num com) const {
        Complex result(R + com, I);
        return result;
    }

    Complex operator + () const {
        Complex result(R, I);
        return result;
    }

    Complex operator - (const Complex& com) const {
        Complex result(R - com.Re(), I - com.Im());
        return result;
    }

    template <typename num>
    Complex operator - (num com) const {
        Complex result(R - com, I);
        return result;
    }

    Complex operator - () const {
        Complex result(-R, -I);
        return result;
    }

    Complex operator * (const Complex& com) const {
        Complex result(R * com.Re() - I * com.Im(), R * com.Im() + I * com.Re());
        return result;
    }

    template <typename num>
    Complex operator * (num com) const {
        Complex result(R * com, I * com);
        return result;
    }

    Complex operator / (const Complex& com) const {
        Complex result((R * com.Re() + I * com.Im()) / (exp(2 * log(com.Re())) +
            exp(2 * log(com.Im()))), (I * com.Re() - R * com.Im()) / (exp(2 * log(com.Re())) +
                exp(2 * log(com.Im()))));
        return result;
    }

    template <typename num>
    Complex operator / (num com) const {
        Complex result(R / com, I / com);
        return result;
    }

    bool operator == (const Complex& com) const {
        return ((R == com.Re()) && (I == com.Im()));
    }

    bool operator != (const Complex& com) const {
        return ((R != com.Re()) || (I != com.Im()));
    }
};

double abs(const Complex& com) {
    return exp(0.5 * log(exp(2 * log(com.Re())) + exp(2 * log(com.Im()))));
}

template <typename num>
Complex operator + (num n, const Complex& com) {
    return com + n;
}

template <typename num>
Complex operator * (num n, const Complex& com) {
    return com * n;
}