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

import time
import io
import math
import random

def timer(f):
    def tmp(*args, **kwargs):
        t = time.time()
        res = f(*args, **kwargs)
        print ("Time : %f" % (time.time()-t))
        return res

    return tmp

def gcd(a, b):
    if b == 0:
        return a
    else:
        return gcd(b, a%b)

def f(a, b):
    return Value(gcd(a.val, b.val))

class Value:
    val = 0
    def __init__(self, val):
        self.val = val

    def __str__(self):
        return str(self.val)

    @staticmethod
    def zero():
        return Value(1)

    @staticmethod
    def dif(a, b):
        return Value(a.val - b.val)

class BinaryTree():
    leftChild = None
    rightChild= None
    value = None
    left=0;
    right=0;

    def __init__(self, left, right, value, leftBound, rightBound):
        self.leftChild = left
        self.rightChild = right
        self.value = value;
        self.left = leftBound
        self.right = rightBound

    def print(self, indent):
        if self.leftChild == None:
            return str(self.value)+" ("+str(self.left)+" - "+str(self.right)+")";
        else:
            sleft = self.leftChild.print(indent+1)
            sright = self.rightChild.print(indent+1)
            return str(self.value)+" ("+str(self.left)+" - "+str(self.right)+")"+'\n'+("   "*indent)+sleft+"\n"+("   "*indent)+sright

    @staticmethod
    def build(array, left, right, f):
        if left == right :
            return BinaryTree(None, None, array[left], left, right)
        else:
            middle = (left+right)//2
            leftTree = BinaryTree.build(array, left, middle, f)
            rightTree = BinaryTree.build(array, middle+1, right, f)
            value = f(leftTree.value, rightTree.value)
            return BinaryTree(leftTree, rightTree, value, left, right)

    def query(self, fr, to, f):
        if fr > to:
            return Value.zero()
        if self.left == fr and self.right == to:
            return self.value
        else:
            middle = (self.left+self.right)//2
            leftVal = self.leftChild.query(fr, min(middle, to), f)
            rightVal = self.rightChild.query(max(middle+1, fr), to, f)
            return f(leftVal, rightVal)

    def modify(self, index, newValue, f):
        dif = Value.dif(newValue, self.query(index, index,f))
        if index == self.left and index == self.right:
            self.value = newValue
        else:
            middle = (self.left+self.right)//2
            self.value = f(self.value, dif)
            if index <= middle:
                self.leftChild.modify(index, newValue, f)
            else:
                self.rightChild.modify(index, newValue, f)


@timer
def use():
    array = []
    #for i in range(4):
    #array.append(Value(i+1))

    array.append(Value(4))
    array.append(Value(6))
    array.append(Value(12))
    array.append(Value(4))

    segmentTree = BinaryTree.build(array, 0, len(array)-1, f)
    print(segmentTree.print(1))
    print(segmentTree.query(1, 3, f))
    segmentTree.modify(3, Value(5), f)
    print(segmentTree.print(1))
    print(segmentTree.query(1, 3, f))

#use(
#print(V, a, k)

str = input().split(' ')
x = int(str[0])
y = int(str[1])
m = max(x, y);
ver = 6-m+1;

if ver == 0:
    print("0/1");

if ver == 1:
    print("1/6");

if ver == 2:
    print("1/3");

if ver == 3:
    print("1/2");

if ver == 4:
    print("2/3");

if ver == 5:
    print("5/6");

if ver == 6:
    print("1/1");