#include <iostream>

using namespace std;

long long int A;

int gcd(int a, int b) {
    if (b == 0)
        return a;
    else
        return gcd(b, a % b);
}

class Fraction {
private:
    int x, y;
    static int q;
    static int q1;
public:
    Fraction() {
        x = 0;
        y = 1;
    }
    Fraction(int _x) {
        x = _x;
        y = 1;
        if (q1 == y)
        {
            q += x;
            int z = q, z1 = q1;
            while (gcd(q, q1) != 1) {
                q = q / gcd(z, z1);
                q1 = q1 / gcd(z, z1);
                z = q;
                z1 = q1;
            }
        }
        else
        {
            q = q * y + x * q1;
            q1 = y * q1;
            int z = q, z1 = q1;
            while (gcd(q, q1) != 1) {
                q = q / gcd(z, z1);
                q1 = q1 / gcd(z, z1);
                z = q;
                z1 = q1;
            }
        }
    }
    Fraction(int _x, int _y) {
        x = _x;
        y = _y;
        if (q1 == y)
        {
            q += x;
            int z = q, z1 = q1;
            while (gcd(q, q1) != 1) {
                q = q / gcd(z, z1);
                q1 = q1 / gcd(z, z1);
                z = q;
                z1 = q1;
            }
        }
        else
        {
            q = q * y + x * q1;
            q1 = y * q1;
            int z = q, z1 = q1;
            while (gcd(q, q1) != 1) {
                q = q / gcd(z, z1);
                q1 = q1 / gcd(z, z1);
                z = q;
                z1 = q1;
            }
        }
    }
    Fraction(const Fraction& v)
    {
        x = v.x;
        y = v.y;
        if (q1 == y)
        {
            q += x;
            int z = q, z1 = q1;
            while (gcd(q, q1) != 1) {
                q = q / gcd(z, z1);
                q1 = q1 / gcd(z, z1);
                z = q;
                z1 = q1;
            }
        }
        else
        {
            q = q * y + x * q1;
            q1 = y * q1;
            int z = q, z1 = q1;
            while (gcd(q, q1) != 1) {
                q = q / gcd(z, z1);
                q1 = q1 / gcd(z, z1);
                z = q;
                z1 = q1;
            }
        }

    }
    static Fraction getSum() {
        Fraction w(q, q1);
        return w;
    }
    friend ostream& operator <<(ostream&, const Fraction&);
    friend istream& operator >> (istream&, Fraction&);
    Fraction operator +(const Fraction);
    ~Fraction() {
        if (q1 == y)
        {
            q -= x;
            int z = q, z1 = q1;
            while (gcd(q, q1) != 1) {
                q = q / gcd(z, z1);
                q1 = q1 / gcd(z, z1);
                z = q;
                z1 = q1;
            }
        }
        else
        {
            q = q * y - x * q1;
            q1 = y * q1;
            int z = q, z1 = q1;
            while (gcd(q, q1) != 1) {
                q = q / gcd(z, z1);
                q1 = q1 / gcd(z, z1);
                z = q;
                z1 = q1;
            }
        }
    }
};

int Fraction::q = 0;
int Fraction::q1 = 1;

istream& operator >> (istream& in, Fraction& v)
{
    int e, d;
    in >> e >> d;
    v.x = e;
    v.y = d;
    int x1 = v.x;
    int y1 = v.y;
    while (gcd(v.x, v.y) != 1) {
        v.x = v.x / gcd(x1, y1);
        v.y = v.y / gcd(x1, y1);
        x1 = v.x;
        y1 = v.y;
    }
    int g = v.x;
    int g1 = v.y;
    if (Fraction::q1 == g1)
    {
        Fraction::q += g;
        int z = Fraction::q, z1 = Fraction::q1;
        while (gcd(Fraction::q, Fraction::q1) != 1) {
            Fraction::q = Fraction::q / gcd(z, z1);
            Fraction::q1 = Fraction::q1 / gcd(z, z1);
            z = Fraction::q;
            z1 = Fraction::q1;
        }
    }
    else
    {
        Fraction::q = Fraction::q * g1 + g * Fraction::q1;
        Fraction::q1 = g1 * Fraction::q1;
        int z = Fraction::q, z1 = Fraction::q1;
        while (gcd(Fraction::q, Fraction::q1) != 1) {
            Fraction::q = Fraction::q / gcd(z, z1);
            Fraction::q1 = Fraction::q1 / gcd(z, z1);
            z = Fraction::q;
            z1 = Fraction::q1;
        }
    }
    return in;
}

ostream& operator <<(ostream& out, const Fraction& v)
{

    if (v.x == 0)
        out << 0;
    else
        if (v.y == 1)
            out << v.x;
        else
            out << v.x << "/" << v.y;
    return out;
}

Fraction Fraction::operator +(const Fraction b)
{
    int i = b.x;
    int i1 = b.y;
    if (i1 == y)
    {
        i += x;
        int z = i, z1 = i1;
        while (gcd(i, i1) != 1) {
            i = i / gcd(z, z1);
            i1 = i1 / gcd(z, z1);
            z = i;
            z1 = i1;
        }
    }
    else
    {
        i = i * y + x * i1;
        i1 = y * i1;
        int z = i, z1 = i1;
        while (gcd(i, i1) != 1) {
            i = i / gcd(z, z1);
            i1 = i1 / gcd(z, z1);
            z = i;
            z1 = i1;
        }
    }
    Fraction w(i, i1);
    return w;
}