6 6
 1 4
 4 4
 3 3
 6 4
 6 3
 5 4
 5 6
 3 4
 1 3
 3 2
 5 5
 1 1
 2 1
 3 1
 3 5
 1 6
 6 5
 2 3
 4 3
 2 2
 3 6
 1 2
 6 1
 2 5
 4 5
 1 5
 6 2
 4 6
 5 1
 4 1
 5 2
 2 4
 2 6
 5 3

1/6
 1/2
 1/2
 2/3
 1/6
 1/6
 1/3
 1/6
 1/2
 2/3
 2/3
 1/3
 1/1
 5/6
 2/3
 1/3
 1/6
 1/6
 2/3
 1/2
 5/6
 1/6
 5/6
 1/6
 1/3
 1/3
 1/3
 1/6
 1/6
 1/3
 1/2
 1/3
 1/2
 1/6
 1/3

from math import *

def gcd(m,n):
    if n == 0:
        return m
    elif m == 0:
        return n
    elif n > m:
        return gcd(m,n%m)
    else:
        return gcd(m%n,n)

s = raw_input()
l = s.split(' ')
m = max(int(l[0]), int(l[1]))
p = 6 - m + 1
d = gcd(p,6)
print(str(p/d)+'/'+str(6/d))

"""l = [5,3,4]
print(BIS(l))"""



"""from math import *
from Queue import *

def bfs(G, start):
    visited = set([start])
    Q = Queue()
    Ret = [start]
    Q.put(start)
    while not Q.empty():
        vertex = Q.get()
        for v in G[1][vertex]:
            if v not in visited:
                Q.put(v)
                visited.add(v)
                Ret.append(v)
    return Ret

def longest_path(G):
    l = bfs(G,G[0][0])
    marked = set()
    result = dict()
    for i in l:
        result[i] = [0,i,0,i]
    for i in range(len(l)-1, -1, -1):
        for j in G[1][l[i]]:
            if j in marked:
                if (result[j][2] > result[l[i]][2]) or ((result[j][2] == result[l[i]][2]) and (result[j][3] < result[l[i]][3])):
                    result[l[i]][2] = result[j][2]
                    result[l[i]][3] = result[j][3]
                if (result[l[i]][0] + result[j][0] + 1 > result[l[i]][2]):
                    result[l[i]][2] = result[l[i]][0] + result[j][0] + 1
                    result[l[i]][3] = min(result[l[i]][1], result[j][1])
                if ((result[l[i]][0] + result[j][0] + 1 == result[l[i]][2]) and (min(result[l[i]][1],result[j][1]) < result[l[i]][3])):
                    result[l[i]][3] = min(result[l[i]][1],result[j][1])
                if (result[j][0] + 1 > result[l[i]][0]) or ((result[j][0] + 1 == result[l[i]][0]) and (result[j][1] < result[l[i]][1])):
                    result[l[i]][0] = result[j][0] + 1
                    result[l[i]][1] = result[j][1]
        marked.add(l[i])
    return (result[l[0]][2], result[l[0]][3])

def remove(G,v):
    ver = G[0]
    ver.remove(v)
    edg = dict()
    for i in ver:
        nb = []
        for j in G[1][i]:
            if j != v:
                nb.append(j)
        edg[i] = nb
    return (ver, edg)

def harvest(G,M):
    l = bfs(G,M[0])
    seen = set()
    delete = []
    for i in range(len(l)-1, -1, -1):
        seen.add(l[i])
        if l[i] in M:
            for j in G[1][l[i]]:
                if j not in seen:
                    M.append(j)
        if l[i] not in M:
            delete.append(l[i])
    for i in delete:
        G = remove(G,i)
    return G

s = raw_input()
l = s.split(' ')
n = int(l[0])
m = int(l[1])
V = []
Adj = [[] for i in range(n+1)]
for i in range(1,n+1):
    V.append(i)
E = dict()
for i in range(n-1):
    s = raw_input()
    l = s.split(' ')
    h = int(l[0])
    t = int(l[1])
    Adj[h].append(t)
    Adj[t].append(h)
E = dict()
for i in range(1, n+1):
    E[i] = Adj[i]
G = [V,E]
s = raw_input()
l = s.split(' ')
M = []
for i in range(m):
    M.append(int(l[i]))
G = harvest(G,M)
sol = longest_path(G)
print(sol[1])
print(2*len(G[0]) - 2 - sol[0])"""
