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 java.io.*;
//import java.util.Iterator;
//import java.util.StringTokenizer;
import java.util.*;

public class Kubik {
    public void solve() {
        //////////////////////////////////////////
        int a = in.nextInt();
        int b = in.nextInt();
        //int a = 4; int b = 2;
        int maxi = 0;
        //System.out.println("n=" + n);
        //int [] a; a = new int[n];
        //for (int i = 0; i < n; i++) { a [i] = in.nextInt(); }
        //int [] a = {1,2,4,3,3};
//----------------------------------------
        if ( maxi < a ) { maxi = a;}
        if ( maxi < b ) { maxi = b;}
//----------------------------------------
        if ( maxi == 1 ) { System.out.println("1/1");}
        if ( maxi == 2 ) { System.out.println("5/6");}
        if ( maxi == 3 ) { System.out.println("2/3");}
        if ( maxi == 4 ) { System.out.println("1/2");}
        if ( maxi == 5 ) { System.out.println("1/3");}
        if ( maxi == 6 ) { System.out.println("0/1");}

    //////////////////////////////////////////
    }
    public static void main(String args[]) {
        new Kubik().run();
    }

    InputReader in;
    OutputWriter out;

    public void run() {
        in = new InputReader(System.in);
        out = new OutputWriter(System.out);

        solve();

        out.flush();
        in.close();
    }

    static class InputReader implements Iterable<String> {
        BufferedReader br;
        StringTokenizer in;

        public InputReader(String fileName) {
            try {
                br = new BufferedReader(new FileReader(fileName));
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

        public InputReader(InputStream inputStream) {
            br = new BufferedReader(new InputStreamReader(inputStream));
        }

        public InputReader() {
            this(System.in);
        }

        String lastLine = null;

        private boolean hasMoreTokens() {
            while (in == null || !in.hasMoreTokens()) {
                lastLine = nextLine();
                if (lastLine == null) {
                    return false;
                }
                in = new StringTokenizer(lastLine);
            }
            return true;
        }

        public String nextString() {
            return hasMoreTokens() ? in.nextToken() : null;
        }

        public String nextLine() {
            boolean somethingLeft = in != null && in.hasMoreTokens();
            in = null;
            if (somethingLeft) {
                return lastLine;
            }
            try {
                return br.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

        public int nextInt() {
            return Integer.parseInt(nextString());
        }

        public long nextLong() {
            return Long.parseLong(nextString());
        }

        public double nextDouble() {
            return Double.parseDouble(nextString());
        }

        public int[] nextIntArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = nextInt();
            }
            return a;
        }

        public long[] nextLongArray(int n) {
            long[] a = new long[n];
            for (int i = 0; i < n; i++) {
                a[i] = nextLong();
            }
            return a;
        }

        public double[] nextDoubleArray(int n) {
            double[] a = new double[n];
            for (int i = 0; i < n; i++) {
                a[i] = nextDouble();
            }
            return a;
        }

        public String[] nextStringArray(int n) {
            String[] a = new String[n];
            for (int i = 0; i < n; i++) {
                a[i] = nextString();
            }
            return a;
        }

        public String[] nextLineArray(int n) {
            String[] a = new String[n];
            for (int i = 0; i < n; i++) {
                a[i] = nextLine();
            }
            return a;
        }

        @Deprecated
        public String next() {
            return nextString();
        }

        public String readAll() {
            StringBuilder stringBuilder = new StringBuilder();
            int c;
            try {
                while ((c = br.read()) != -1) {
                    stringBuilder.append((char) c);
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            return stringBuilder.toString();
        }

        @Override
        public Iterator<String> iterator() {
            return new Iterator<String>() {
                @Override
                public boolean hasNext() {
                    return hasMoreTokens();
                }

                @Override
                public String next() {
                    return nextString();
                }

                @Override
                public void remove() {
                    throw new RuntimeException();
                }
            };
        }

        public void close() {
            in = null;
            try {
                br.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            br = null;
        }
    }

    static class OutputWriter extends PrintWriter {
        static final String DEFAULT_SEPARATOR = " ";

        public OutputWriter(String fileName) {
            super(createFileWriter(fileName));
        }

        private static Writer createFileWriter(String s) {
            Writer writer;

            try {
                writer = new FileWriter(s);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }

            return writer;
        }

        public OutputWriter(OutputStream outputStream) {
            super(outputStream);
        }

        public OutputWriter(Writer writer) {
            super(writer);
        }

        public void print(Object... objects) {
            printSeparated(DEFAULT_SEPARATOR, objects);
        }

        public void println(Object... objects) {
            printSeparated(DEFAULT_SEPARATOR, objects);
            println();
        }

        public void printSeparated(String separator, Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i > 0) {
                    print(separator);
                }
                print(objects[i]);
            }
        }

        public void print(Iterable<?> from) {
            printSeparated(DEFAULT_SEPARATOR, from);
        }

        public void printSeparated(String separator, Iterable<?> from) {
            boolean first = true;
            for (Object object : from) {
                if (!first) {
                    print(separator);
                } else {
                    first = false;
                }
                print(object);
            }
        }

        public void println(int a, int b) {
            print(a);
            print(" ");
            print(b);
            println();
        }
    }
}