sda

#pragma once
#include <exception>

int gcd(int first_number, int second_number) {
  throw std::logic_error("Not implemented");
}

class Fraction {
 public:
  Fraction() {
      num_ = 0;
      den_ = 1;
  }
  Fraction(int num, int den) {
      if (den == 0) {
          throw den;
      }
      num_ = num;
      den_ = den;
  }
  explicit Fraction(int num) {
      num_ = num;
      den_ = 1;
  } // explicit here is just for PCF :)
  Fraction(const Fraction& other) {
      num_ = other.num_;
      den_ = other.den_;
  }
  ~Fraction() {};

  int num() const {
      return num_;
  }
  int den() const {
      return den_;
  }

  Fraction& operator=(Fraction other) {
      swap(*this, other);
      return *this;
  }

  friend Fraction operator-(Fraction& op);

  friend Fraction operator+(Fraction& op);

  friend Fraction operator+(Fraction lhs, Fraction rhs);

  friend Fraction operator+(Fraction lhs, int rhs);

  friend Fraction operator+(int lhs, Fraction rhs);

  friend Fraction operator-(Fraction lhs, Fraction rhs);

  friend Fraction operator-(Fraction lhs, int rhs);

  friend Fraction operator-(int lhs, Fraction rhs);

  friend Fraction operator*(Fraction lhs, Fraction rhs);

  friend Fraction operator*(Fraction lhs, int rhs);

  friend Fraction operator*(int lhs, Fraction rhs);

  friend Fraction operator/(Fraction lhs, Fraction rhs);

  friend Fraction operator/(Fraction lhs, int rhs);

  friend Fraction operator/(int lhs, Fraction rhs);

  friend Fraction operator+=(Fraction& lhs, Fraction rhs);

  friend Fraction operator+=(Fraction& lhs, int rhs);

  friend Fraction operator-=(Fraction& lhs, Fraction rhs);

  friend Fraction operator-=(Fraction& lhs, int rhs);

  friend Fraction& operator*=(Fraction& lhs, Fraction rhs);

  friend Fraction& operator*=(Fraction& lhs, int rhs);

  friend Fraction& operator/=(Fraction& lhs, Fraction rhs);

  friend Fraction& operator/=(Fraction& lhs, int rhs);

  friend Fraction operator++(Fraction& op);

  friend Fraction operator++(Fraction op, int notused);

  friend Fraction operator--(Fraction& op);

  friend Fraction operator--(Fraction op, int notused);

  friend bool operator<(Fraction lhs, Fraction rhs);

  friend bool operator<(Fraction lhs, int rhs);

  friend bool operator<(int lhs, Fraction rhs);

  friend bool operator>(Fraction lhs, Fraction rhs);

  friend bool operator>(Fraction lhs, int rhs);

  friend bool operator>(int lhs, Fraction rhs);

  friend bool operator<=(Fraction lhs, Fraction rhs);

  friend bool operator<=(Fraction lhs, int rhs);

  friend bool operator<=(int lhs, Fraction rhs);

  friend bool operator>=(Fraction lhs, Fraction rhs);

  friend bool operator>=(Fraction lhs, int rhs);

  friend bool operator>=(int lhs, Fraction rhs);

  friend bool operator==(Fraction lhs, Fraction rhs);

  friend bool operator==(Fraction lhs, int rhs);

  friend bool operator==(int lhs, Fraction rhs);

  friend bool operator!=(Fraction lhs, Fraction rhs);

  friend bool operator!=(Fraction lhs, int rhs);

  friend bool operator!=(int lhs, Fraction rhs);

  friend std::ostream& operator<<(std::ostream& out, const Fraction& fract);

 private:
  void swap(Fraction& a, Fraction& b) {
      Fraction temp = std::move(a);
      a = std::move(b);
      b = std::move(temp);
  }
  int num_, den_;
};

std::ostream& operator<<(std::ostream& out, const Fraction& fract) {
    throw std::logic_error("Not implemented");
}

Fraction operator-(Fraction& op) {
    op.num_ = -op.num_;
    return op;
}

Fraction operator+(Fraction& op) {
    return op;
}

Fraction operator+(Fraction lhs, Fraction rhs) {
    if (lhs.den_ != rhs.den_) {
        lhs.num_ = lhs.num_ * rhs.den_ + rhs.num_ * lhs.den_;
        lhs.den_ *= rhs.den_;
        return lhs;
    }
    lhs.num_ += rhs.num_;
    return lhs;
}

Fraction operator+(Fraction lhs, int rhs) {
    lhs.num_ += rhs * lhs.den_;
    return lhs;
}

Fraction operator+(int lhs, Fraction rhs) {
    rhs.num_ += lhs * rhs.den_;
    return rhs;
}

Fraction operator-(Fraction lhs, Fraction rhs) {
    if (lhs.den_ != rhs.den_) {
        lhs.num_ = lhs.num_ * rhs.den_ - rhs.num_ * lhs.den_;
        lhs.den_ *= rhs.den_;
        return lhs;
    }
    lhs.num_ -= rhs.num_;
    return lhs;
}

Fraction operator-(Fraction lhs, int rhs) {
    lhs.num_ -= rhs * lhs.den_;
    return lhs;
}

Fraction operator-(int lhs, Fraction rhs) {
    rhs.num_ -= lhs * rhs.den_;
    return rhs;
}

Fraction operator*(Fraction lhs, Fraction rhs) {
    lhs.num_ *= rhs.num_;
    lhs.den_ *= rhs.den_;
    return lhs;
}

Fraction operator*(Fraction lhs, int rhs) {
    lhs.num_ *= rhs;
    return lhs;
}

Fraction operator*(int lhs, Fraction rhs) {
    rhs.num_ *= lhs;
    return rhs;
}

Fraction operator/(Fraction lhs, Fraction rhs) {
    lhs.num_ *= rhs.den_;
    lhs.den_ *= rhs.num_;
    return lhs;
}

Fraction operator/(Fraction lhs, int rhs) {
    lhs.den_ *= rhs;
    return lhs;
}

Fraction operator/(int lhs, Fraction rhs) {
    rhs.den_ *= lhs;
    return rhs;
}

Fraction operator+=(Fraction& lhs, Fraction rhs) {
    lhs = lhs + rhs;
    return lhs;
}

Fraction operator+=(Fraction& lhs, int rhs) {
    lhs = lhs + rhs;
    return lhs;
}

Fraction operator-=(Fraction& lhs, Fraction rhs) {
    lhs = lhs - rhs;
    return lhs;
}

Fraction operator-=(Fraction& lhs, int rhs) {
    lhs = lhs - rhs;
    return lhs;
}

Fraction& operator*=(Fraction& lhs, Fraction rhs) {
    lhs = lhs * rhs;
    return lhs;
}

Fraction& operator*=(Fraction& lhs, int rhs) {
    lhs = lhs * rhs;
    return lhs;
}

Fraction& operator/=(Fraction& lhs, Fraction rhs) {
    lhs = lhs / rhs;
    return lhs;
}

Fraction& operator/=(Fraction& lhs, int rhs) {
    lhs = lhs / rhs;
    return lhs;
}

Fraction operator++(Fraction& op) {
    op += 1;
    return op;
}

Fraction operator++(Fraction op, int notused) {
    Fraction temp = op;
    op += 1;
    return op;
}

Fraction operator--(Fraction& op) {
    op -= 1;
    return op;
}

Fraction operator--(Fraction op, int notused) {
    Fraction temp = op;
    op -= 1;
    return op;
}

bool operator<(Fraction lhs, Fraction rhs) {
    return lhs.num_ * rhs.den_ < rhs.num_* lhs.den_;
}

bool operator<(Fraction lhs, int rhs) {
    return lhs.num_ < rhs * lhs.den_;
}

bool operator<(int lhs, Fraction rhs) {
    return lhs < lhs * rhs.den_;
}

bool operator>(Fraction lhs, Fraction rhs) {
    return rhs < lhs;
}

bool operator>(Fraction lhs, int rhs) {
    return rhs < lhs;
}

bool operator>(int lhs, Fraction rhs) {
    return rhs < lhs;
}

bool operator<=(Fraction lhs, Fraction rhs) {
    return !(lhs > rhs);
}

bool operator<=(Fraction lhs, int rhs) {
    return !(lhs > rhs);
}

bool operator<=(int lhs, Fraction rhs) {
    return !(lhs > rhs);
}

bool operator>=(Fraction lhs, Fraction rhs) {
    return !(lhs < rhs);
}

bool operator>=(Fraction lhs, int rhs) {
    return !(lhs < rhs);
}

bool operator>=(int lhs, Fraction rhs) {
    return !(lhs < rhs);
}

bool operator==(Fraction lhs, Fraction rhs) {
    return rhs >= lhs && rhs <= lhs;
}

bool operator==(Fraction lhs, int rhs) {
    return rhs >= lhs && rhs <= lhs;
}

bool operator==(int lhs, Fraction rhs) {
    return rhs >= lhs && rhs <= lhs;
}

bool operator!=(Fraction lhs, Fraction rhs) {
    return !(lhs == rhs);
}

bool operator!=(Fraction lhs, int rhs) {
    return !(lhs == rhs);
}

bool operator!=(int lhs, Fraction rhs) {
    return !(lhs == rhs);
}