#include <vector>
#include <string>

class BigInteger {
public:
    BigInteger();
    BigInteger(int number);
    BigInteger(std::string s);

    ~BigInteger();

    bool operator==(const BigInteger &second) const;
    bool operator<=(const BigInteger &second) const;
    bool operator!=(const BigInteger &second) const;
    bool operator>=(const BigInteger &second) const;
    bool operator>(const BigInteger &second) const;
    bool operator<(const BigInteger &second) const;

    BigInteger operator+(const BigInteger &second) const;
    BigInteger operator-(const BigInteger &second) const;
    BigInteger operator*(const BigInteger &second) const;
    BigInteger operator%(const BigInteger &second) const;
    BigInteger operator/(const BigInteger &second) const;

    BigInteger &operator+=(const BigInteger &second);
    BigInteger &operator-=(const BigInteger &second);
    BigInteger &operator*=(const BigInteger &second);
    BigInteger &operator%=(const BigInteger &second);
    BigInteger &operator/=(const BigInteger &second);

    const BigInteger operator-() const;

    BigInteger &operator++();
    BigInteger operator++(int);
    BigInteger &operator--();
    BigInteger operator--(int);

    explicit operator bool() const;
    std::string toString() const;

private:
    std::vector<char> numbers_;
    int sign_;

    int length() const {
        return (int)numbers_.size();
    }
};

BigInteger::BigInteger() : sign_(0) {}

BigInteger::BigInteger(int number) {
    sign_ = 0;

    if (number > 0) {
        sign_ = 1;
    } else if (number < 0) {
        sign_ = -1;
        number *= -1;
    }

    while (number) {
        numbers_.push_back((char)(number % 10));
        number /= 10;
    }
}

BigInteger::BigInteger(std::string s) {
    sign_ = 1;

    if (s.length() == 0 || (s.length() == 1 && s[0] == '0')) {
        sign_ = 0;
        return;
    }

    int last = 0;
    if (s.length() != 0 && s[0] == '-') {
        sign_ = -1;
        last = 1;
    }

    if (s.length() != 0 && s[0] == '+') {
        last = 1;
    }

    for (int i = (int)s.length() - 1; i >= last; i--) {
        numbers_.push_back(s[i] - '0');
    }
}

BigInteger::~BigInteger() {
    numbers_.clear();
}

bool BigInteger::operator==(const BigInteger &second) const {
    if (sign_ != second.sign_ || length() != second.length()) {
        return false;
    }

    for (int i = 0; i < length(); ++i) {
        if (numbers_[i] != second.numbers_[i]) {
            return false;
        }
    }

    return true;
}

bool BigInteger::operator<=(const BigInteger &second) const {
    return *this < second || second == *this;
}

bool BigInteger::operator!=(const BigInteger &second) const {
    return !((*this) == second);
}

bool BigInteger::operator>=(const BigInteger &second) const {
    return second < *this || second == *this;
}

bool BigInteger::operator>(const BigInteger &second) const {
    return second < *this;
}

bool BigInteger::operator<(const BigInteger &second) const {
    if (sign_ != second.sign_) {
        return sign_ < second.sign_;
    }

    if (length() == second.length()) {
        for (int i = length() - 1; i >= 0; --i) {
            if (numbers_[i] != second.numbers_[i]) {
                return numbers_[i] < second.numbers_[i];
            }
        }

        return false;
    }

    return length() < second.length();
}

BigInteger BigInteger::operator+(const BigInteger &second) const {
    if (!sign_)
        return second;

    if (!second.sign_) {
        return *this;
    }

    if (second.sign_ == -1 && sign_ == 1) {
        return (*this) - (-second);
    }

    if (second.sign_ == 1 && sign_ == -1) {
        return (second) - (-*this);
    }

    if (second.sign_ == -1 && sign_ == -1) {
        return -((-second) + (-*this));
    }

    BigInteger result;
    int add = 0;
    for (int i = 0; i < std::max(second.length(), length()); i++) {
        int now = add + (i < second.length() ? second.numbers_[i] : 0) + (i < length() ? numbers_[i] : 0);
        add = now / 10;
        now %= 10;

        result.numbers_.push_back(now);
    }
    if (add != 0) {
        result.numbers_.push_back(add);
    }
    result.sign_ = 1;

    return result;
}

BigInteger BigInteger::operator-(const BigInteger &second) const {
    if (*this == second)
        return BigInteger();

    if (!sign_)
        return -second;

    if (!second.sign_) {
        return *this;
    }

    if (second.sign_ == -1 && sign_ == 1) {
        return (*this) + (-second);
    }

    if (second.sign_ == 1 && sign_ == -1) {
        return -((-*this) + second);
    }

    if (second.sign_ == -1 && sign_ == -1) {
        return (-second) - (-*this);
    }

    if (*this < second) {
        return -(second - *this);
    }

    BigInteger result;
    int add = 0;
    for (int i = 0; i < length(); i++) {
        int now = numbers_[i] - (i < second.length() ? second.numbers_[i] : 0) - add;

        if (now < 0) {
            now += 10;
            add = 1;
        } else {
            add = 0;
        }

        result.numbers_.push_back(now);
    }
    while (!result.numbers_.empty() && !result.numbers_.back()) {
        result.numbers_.pop_back();
    }

    result.sign_ = 1;

    return result;
}

BigInteger &BigInteger::operator+=(const BigInteger &second) {
    return (*this) = *this + second;
}

BigInteger &BigInteger::operator-=(const BigInteger &second) {
    return (*this) = *this - second;
}

const BigInteger BigInteger::operator-() const {
    BigInteger res = *this;
    res.sign_ *= -1;

    return res;
}

BigInteger BigInteger::operator*(const BigInteger &second) const {
    if (!second.length() || !length()) {
        return BigInteger();
    }
    int new_sign_ = second.sign_ * sign_;

    BigInteger res = BigInteger();
    res.sign_ = 1;

    for (int i = 0; i < length(); ++i) {
        BigInteger add = BigInteger();
        add.sign_ = 1;

        if (!numbers_[i]) {
            continue;
        }

        for (int j = 0; j < i; ++j) {
            add.numbers_.push_back(0);
        }
        int nexts = 0;
        for (int j = 0; j < second.length(); ++j) {
            int now = numbers_[i] * second.numbers_[j] + nexts;

            nexts = now / 10;
            now %= 10;

            add.numbers_.push_back(now);
        }
        if (nexts != 0) {
            add.numbers_.push_back(nexts);
        }
        res = res + add;
    }
    res.sign_ = new_sign_;

    return res;
}

BigInteger BigInteger::operator/(const BigInteger &second) const {
    int sign = this->sign_ * second.sign_;

    BigInteger now = *this, s = second, result = 0, part = 0;
    now.sign_ = 1;
    s.sign_ = 1;

    if (now < s) {
        return 0;
    }

    while (part < s) {
        part *= 10;
        part += now.numbers_.back();
        now.numbers_.pop_back();
    }
    int number = 9;
    for (;s * number > part; number--) {}

    part -= s * number;
    result *= 10;
    result += number;

    while (now.numbers_.size() != 0) {
        part *= 10;
        part += now.numbers_.back();
        now.numbers_.pop_back();

        int number = 9;
        for (;s * number > part; number--) {}

        part -= s * number;
        result *= 10;
        result += number;
    }
    result.sign_ = sign;

    return result;
}

BigInteger &BigInteger::operator*=(const BigInteger &second) {
    return (*this) = *this * second;
}

BigInteger &BigInteger::operator/=(const BigInteger &second) {
    return (*this) = *this / second;
}

BigInteger &BigInteger::operator%=(const BigInteger &second) {
    return (*this) = *this % second;
}

BigInteger BigInteger::operator%(const BigInteger &second) const {
    return (*this) - (second * (*this / second));
}

BigInteger &BigInteger::operator--() {
    return operator-=(1);
}

BigInteger BigInteger::operator--(int) {
    BigInteger result(*this);
    operator-=(1);

    return result;
}

BigInteger &BigInteger::operator++() {
    return operator+=(1);
}

BigInteger BigInteger::operator++(int) {
    BigInteger result(*this);
    operator+=(1);

    return result;
}

 BigInteger::operator bool() const {
    return sign_ != 0;
}

std::string BigInteger::toString() const {
    std::string result = "";

    if (sign_ == 0) {
        result += '0';
    } else if (sign_ == -1) {
        result += '-';
    }

    for (int i = length() - 1; i >= 0; i--) {
        result += (char)(numbers_[i] + '0');
    }
    return result;
}

std::istream &operator>>(std::istream &i, BigInteger &object) {
    std::string s;
    i >> s;

    object = BigInteger(s);

    return i;
}

std::ostream &operator<<(std::ostream &i, const BigInteger &object) {
    i << object.toString();

    return i;
}

BigInteger operator+(int n, BigInteger &second) {
    return BigInteger(n) + second;
}

BigInteger operator-(int n, BigInteger &second) {
    return BigInteger(n) - second;
}

BigInteger operator*(int n, BigInteger &second) {
    return BigInteger(n) * second;
}

BigInteger operator%(int n, BigInteger &second) {
    return BigInteger(n) % second;
}

BigInteger operator/(int n, BigInteger &second) {
    return BigInteger(n) / second;
}