private static int lcm(Fraction a, Fraction b) {
        return lcm(a.denom, b.denom);
    }

    private static int lcm(int a, int b) {
        if (a == 0 && b == 0) {
            return 0;
        }
        int gcd = euclidGcd(a, b);
        return (int) (Math.abs((long) a * (long) b) / gcd);
    }

    private static int euclidGcd(int a, int b) {
        a = Math.abs(a);
        b = Math.abs(b);
        // GCD of equal numbers is also equal to the numbers
        if (a == b) {
            return a;
        }
        // Algorithm depends on a > b
        if (a < b) {
            int temp = a;
            a = b;
            b = temp;
        }
        // Apply Euclid's algorithm
        while (b != 0) {
            int temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }

    private static class Fraction extends Number {

        public final int num, denom;

        public Fraction() {
            this(0);
        }

        public Fraction(int num) {
            this(num, 1);
        }

        public Fraction(int num, int denom) {
            if (denom == 0) {
                throw new IllegalStateException("Invalid fraction.");
            }
            // Move negative sign to numerator
            if (denom < 0) {
                num = -num;
                denom = -denom;
            }
            // Always simplify fractions. Since fractions are immutable, this guarantees simplification of all fractions.
            int gcd = euclidGcd(num, denom);
            if (gcd > 1) {
                num /= gcd;
                denom /= gcd;
            }
            this.num = num;
            this.denom = denom;
        }

        public Fraction inverse() {
            if (num == 0) {
                return this;
            }
            return new Fraction(denom, num);
        }

        public Fraction add(Fraction other) {
            int lcm = lcm(denom, other.denom);
            int newNum = scaleNumerator(lcm) + other.scaleNumerator(lcm);
            return new Fraction(newNum, lcm);
        }

        public Fraction sub(Fraction other) {
            int lcm = lcm(denom, other.denom);
            int newNum = scaleNumerator(lcm) - other.scaleNumerator(lcm);
            return new Fraction(newNum, lcm);
        }

        public Fraction mul(Fraction other) {
            return new Fraction(num * other.num, denom * other.denom);
        }

        public Fraction div(Fraction other) {
            return mul(other.inverse());
        }

        public int scaleNumerator(int denom) {
            if (num == 0) return 0;
            if (denom % this.denom != 0) {
                throw new IllegalArgumentException("Given denominator is not a multiple of the current denominator");
            }
            return num * (denom / this.denom);
        }

        @Override
        public double doubleValue() {
            return (double) num / denom;
        }

        @Override
        public float floatValue() {
            return (float) num / denom;
        }

        @Override
        public int intValue() {
            return (int) doubleValue();
        }

        @Override
        public long longValue() {
            return (long) doubleValue();
        }

        @Override
        public String toString() {
            return num + "/" + denom;
        }
    }