Manao has a monitor. The screen of the monitor has horizontal to vertical length ratio a:b. Now he is going to watch a movie. The movie's frame has horizontal to vertical length ratio c:d. Manao adjusts the view in such a way that the movie preserves the original frame ratio, but also occupies as much space on the screen as possible and fits within it completely. Thus, he may have to zoom the movie in or out, but Manao will always change the frame proportionally in both dimensions.

Calculate the ratio of empty screen (the part of the screen not occupied by the movie) to the total screen size. Print the answer as an irreducible fraction p / q.

Input

A single line contains four space-separated integers a, b, c, d (1 ≤ a, b, c, d ≤ 1000).

Output

Print the answer to the problem as "p/q", where p is a non-negative integer, q is a positive integer and numbers p and q don't have a common divisor larger than 1.

Examples

Input

1 1 3 2


Output

1/3


Input

4 3 2 2


Output

1/4

Note

Sample 1. Manao's monitor has a square screen. The movie has 3:2 horizontal to vertical length ratio. Obviously, the movie occupies most of the screen if the width of the picture coincides with the width of the screen. In this case, only 2/3 of the monitor will project the movie in the horizontal dimension: <image>

Sample 2. This time the monitor's width is 4/3 times larger than its height and the movie's frame is square. In this case, the picture must take up the whole monitor in the vertical dimension and only 3/4 in the horizontal dimension: <image>
import java.io.*;
import java.math.*;
import java.util.*;
import java.util.stream.*;

@SuppressWarnings("unchecked")
public class P337B {

  public void run() throws Exception {
    Fraction sw = new Fraction(nextInt());
    Fraction sh = new Fraction(nextInt());
    Fraction fw = new Fraction(nextInt());
    Fraction fh = new Fraction(nextInt());
    Fraction ss = sw.mul(sh);
    Fraction kf = sw.div(fw).min(sh.div(fh));
    fw = fw.mul(kf);
    fh = fh.mul(kf);
    Fraction fs = fw.mul(fh);
    Fraction ans = Fraction.ONE.sub(fs.div(ss));

    println(ans);
  }

  public static void main(String... args) throws Exception {
    br = new BufferedReader(new InputStreamReader(System.in));
    pw = new PrintWriter(new BufferedOutputStream(System.out));
    new P337B().run();
    br.close();
    pw.close();
    System.err.println("\n[Time : " + (System.currentTimeMillis() - startTime) + " ms]");
  }

  static long startTime = System.currentTimeMillis();
  static BufferedReader br;
  static PrintWriter pw;
  StringTokenizer stok;

  String nextToken() throws IOException {
    while (stok == null || !stok.hasMoreTokens()) {
      String s = br.readLine();
      if (s == null) { return null; }
      stok = new StringTokenizer(s);
    }
    return stok.nextToken();
  }

  void print(byte b) { print("" + b); }
  void print(int i) { print("" + i); }
  void print(long l) { print("" + l); }
  void print(double d) { print("" + d); }
  void print(char c) { print("" + c); }
  void print(Object o) {
    if (o instanceof int[]) { print(Arrays.toString((int [])o));
    } else if (o instanceof long[]) { print(Arrays.toString((long [])o));
    } else if (o instanceof char[]) { print(Arrays.toString((char [])o));
    } else if (o instanceof byte[]) { print(Arrays.toString((byte [])o));
    } else if (o instanceof short[]) { print(Arrays.toString((short [])o));
    } else if (o instanceof boolean[]) { print(Arrays.toString((boolean [])o));
    } else if (o instanceof float[]) { print(Arrays.toString((float [])o));
    } else if (o instanceof double[]) { print(Arrays.toString((double [])o));
    } else if (o instanceof Object[]) { print(Arrays.toString((Object [])o));
    } else { print("" + o); }
  }
  void print(String s) { pw.print(s); }
  void println() { println(""); }
  void println(byte b) { println("" + b); }
  void println(int i) { println("" + i); }
  void println(long l) { println("" + l); }
  void println(double d) { println("" + d); }
  void println(char c) { println("" + c); }
  void println(Object o) { print(o); println(); }
  void println(String s) { pw.println(s); }
  int nextInt() throws IOException { return Integer.parseInt(nextToken()); }
  long nextLong() throws IOException { return Long.parseLong(nextToken()); }
  double nextDouble() throws IOException { return Double.parseDouble(nextToken()); }
  char nextChar() throws IOException { return (char) (br.read()); }
  String next() throws IOException { return nextToken(); }
  String nextLine() throws IOException { return br.readLine(); }
  int [] readInt(int size) throws IOException {
    int [] array = new int [size];
    for (int i = 0; i < size; i++) { array[i] = nextInt(); }
    return array;
  }
  long [] readLong(int size) throws IOException {
    long [] array = new long [size];
    for (int i = 0; i < size; i++) { array[i] = nextLong(); }
    return array;
  }
  double [] readDouble(int size) throws IOException {
    double [] array = new double [size];
    for (int i = 0; i < size; i++) { array[i] = nextDouble(); }
    return array;
  }
  String [] readLines(int size) throws IOException {
    String [] array = new String [size];
    for (int i = 0; i < size; i++) { array[i] = nextLine(); }
    return array;
  }

public static class Fraction implements Comparable<Fraction> {
  
  public final static Fraction ZERO = new Fraction(0L, 1L);
  public final static Fraction ONE = new Fraction(1L, 1L);
  public final static Fraction TEN = new Fraction(10L, 1L);

  private BigInteger div = null;
  private BigInteger rem = null;

  private Fraction() {;}

  public Fraction(long div) {
    this(div, 1L);
  }

  public Fraction(long div, long rem) {
    this(BigInteger.valueOf(div), BigInteger.valueOf(rem));
  }

  public Fraction(BigInteger div, BigInteger rem) {
    BigInteger gcd = div.gcd(rem);

    if (!gcd.equals(BigInteger.ONE)) {
      div = div.divide(gcd);
      rem = rem.divide(gcd);
    }

    this.div = div;
    this.rem = rem;
  }

  public Fraction(Fraction f) {
    div = f.div;
    rem = f.rem;
  }

  public Fraction add(Fraction f) {
    return (new Fraction(div.multiply(f.rem).add(rem.multiply(f.div)), rem.multiply(f.rem)));
  }

  public Fraction sub(Fraction f) {
    return (new Fraction(div.multiply(f.rem).subtract(rem.multiply(f.div)), rem.multiply(f.rem)));
  }

  public Fraction mul(Fraction f) {
    return (new Fraction(div.multiply(f.div), rem.multiply(f.rem)));
  }

  public Fraction div(Fraction f) {
    return (new Fraction(div.multiply(f.rem), rem.multiply(f.div)));
  }

  // Decimal128
  public BigDecimal bigDecimalValue() {
    return bigDecimalValue(MathContext.DECIMAL128);
  }

  public BigDecimal bigDecimalValue(MathContext mc) {
    return new BigDecimal(div).divide(new BigDecimal(rem), mc);
  }

  // Decimal128
  public double doubleValue() {
    return doubleValue(MathContext.DECIMAL128);
  }

  public double doubleValue(MathContext mc) {
    return (bigDecimalValue(mc).doubleValue());
  }

  public Fraction abs() {
    return (new Fraction(div.abs(), rem));
  }

  public int signum() {
    return div.signum();
  }

  public boolean equals(Fraction f) {
    return (div.equals(f.div) && rem.equals(f.rem));
  }

  public Fraction min(Fraction f) {
    return ((this.sub(f).signum() < 0) ? new Fraction(this) : new Fraction(f));
  }

  public Fraction max(Fraction f) {
    return ((this.sub(f).signum() > 0) ? new Fraction(this) : new Fraction(f));
  }

  @Override
  public int compareTo(Fraction f) {
    return (this.sub(f).signum());
  }

  @Override
  public String toString() {
    return (div + "/" + rem);
  }

  public String toDecimalString() {
    return toDecimalString(MathContext.DECIMAL128);
  }

  public String toDecimalString(MathContext mc) {
    return bigDecimalValue(mc).toString();
  }
}
}