#include <bits/stdc++.h>
using namespace std;
const int MAXN = 505;
struct bign {
  int num[MAXN];
  int l;
  int sig;
  bign(long long n = 0) {
    memset(num, 0, sizeof(num));
    if (n) {
      l = 0;
      if (n < 0) {
        sig = 1;
        n *= -1;
      } else
        sig = 0;
      while (n) {
        num[++l] = n % 10;
        n /= 10;
      }
    } else {
      l = 1;
      sig = 0;
    }
  }
  bign(char s[]) {
    char stk[MAXN];
    int top = 0;
    int ls = strlen(s);
    int i = 0;
    l = 0;
    for (int i = 0; i < MAXN; ++i) {
      num[i] = 0;
    }
    if (s[i] == '-') {
      sig = 1;
      ++i;
    } else if (s[i] == '+') {
      sig = 0;
      ++i;
    } else {
      sig = 0;
    }
    for (; i < ls; ++i) {
      stk[++top] = s[i];
    }
    while (top) {
      num[++l] = stk[top--] - '0';
    }
    while (num[l] == 0 && l > 1) --l;
  }
};
int max1(int a1, int b1) { return a1 > b1 ? a1 : b1; }
int min1(int a1, int b1) { return a1 < b1 ? a1 : b1; }
bool operator<(bign a1, bign b1);
bool operator>(bign a1, bign b1);
bool operator==(bign a1, bign b1);
bool operator!=(bign a1, bign b1);
bool operator>=(bign a1, bign b1);
bool operator<=(bign a1, bign b1);
bign operator+(bign a1, bign b1);
bign operator-(bign a1, bign b1);
bign operator*(bign a1, bign b1);
bign operator/(bign a1, bign b1);
bign operator%(bign a1, bign b1);
void scans(bign &a1);
void prints(bign a1);
bign bigabs(bign a1);
bign bigroot(bign a1, int b1);
bign biggcd(bign x, bign y);
bign bigpow(bign x, int y);
bool operator<(bign a1, bign b1) {
  if (a1.sig ^ b1.sig) {
    return a1.sig ? true : false;
  }
  if (a1.sig) {
    return bigabs(a1) > bigabs(b1);
  }
  if (a1.l != b1.l) return a1.l < b1.l;
  for (int i = a1.l; i; --i) {
    if (a1.num[i] != b1.num[i]) return a1.num[i] < b1.num[i];
  }
  return false;
}
bool operator>(bign a1, bign b1) {
  if (a1.sig ^ b1.sig) {
    return a1.sig ? false : true;
  }
  if (a1.sig) {
    return bigabs(a1) < bigabs(b1);
  }
  if (a1.l != b1.l) return a1.l > b1.l;
  for (int i = a1.l; i; --i) {
    if (a1.num[i] != b1.num[i]) return a1.num[i] > b1.num[i];
  }
  return false;
}
bool operator>=(bign a1, bign b1) { return !(a1 < b1); }
bool operator<=(bign a1, bign b1) { return !(a1 > b1); }
bool operator==(bign a1, bign b1) {
  if (a1.sig != b1.sig || a1.l != b1.l) return false;
  for (int i = a1.l; i; --i) {
    if (a1.num[i] != b1.num[i]) return false;
  }
  return true;
}
bool operator!=(bign a1, bign b1) { return !(a1 == b1); }
bign operator+(bign a1, bign b1) {
  if (a1.sig ^ b1.sig) {
    if (a1.sig) {
      a1.sig ^= 1;
      return b1 - a1;
    } else {
      b1.sig ^= 1;
      return a1 - b1;
    }
  }
  a1.l = max1(a1.l, b1.l) + 1;
  for (int i = 1; i <= a1.l; i++) {
    a1.num[i] += b1.num[i];
    if (a1.num[i] >= 10) {
      a1.num[i + 1] += a1.num[i] / 10;
      a1.num[i] %= 10;
    }
  }
  while (a1.num[a1.l] == 0 && a1.l > 1) --a1.l;
  return a1;
}
bign operator-(bign a1, bign b1) {
  if (a1.sig ^ b1.sig) {
    b1.sig ^= 1;
    return a1 + b1;
  }
  if (bigabs(b1) > bigabs(a1)) {
    bign c1 = b1 - a1;
    c1.sig ^= 1;
    return c1;
  }
  a1.l = max1(a1.l, b1.l);
  for (int i = 1; i <= a1.l; i++) {
    a1.num[i] -= b1.num[i];
    if (a1.num[i] < 0) {
      a1.num[i] += 10;
      a1.num[i + 1] -= 1;
    }
  }
  while (a1.num[a1.l] == 0 && a1.l > 1) --a1.l;
  if (a1.l == 1 && a1.num[1] == 0) a1.sig = 0;
  return a1;
}
bign operator*(bign a1, bign b1) {
  bign c1;
  c1.l = a1.l + b1.l;
  c1.sig = a1.sig ^ b1.sig;
  for (int i = 1; i <= a1.l; ++i) {
    for (int j = 1; j <= b1.l; ++j) {
      c1.num[i + j - 1] += a1.num[i] * b1.num[j];
    }
  }
  for (int i = 1; i <= c1.l; ++i) {
    if (c1.num[i] >= 10) {
      c1.num[i + 1] += c1.num[i] / 10;
      c1.num[i] %= 10;
    }
  }
  while (c1.num[c1.l] == 0 && c1.l > 1) --c1.l;
  if (c1.l == 1 && c1.num[1] == 0) c1.sig = 0;
  return c1;
}
bign operator/(bign a1, bign b1) {
  bign c1, d1, ten = bign(10LL);
  c1.sig = a1.sig ^ b1.sig;
  b1.sig = 0;
  c1.l = a1.l;
  for (int i = a1.l; i >= 1; --i) {
    d1 = d1 * ten;
    d1.num[1] = a1.num[i];
    while (d1 >= b1) {
      d1 = d1 - b1;
      ++c1.num[i];
    }
  }
  while (c1.num[c1.l] == 0 && c1.l > 1) --c1.l;
  if (c1.l == 1 && c1.num[1] == 0) c1.sig = 0;
  return c1;
}
bign operator%(bign a1, bign b1) {
  bign c1, d1, ten = bign(10LL);
  b1.sig = 0;
  c1.l = a1.l;
  for (int i = a1.l; i >= 1; --i) {
    d1 = d1 * ten;
    d1.num[1] = a1.num[i];
    while (d1 >= b1) {
      d1 = d1 - b1;
      ++c1.num[i];
    }
  }
  d1.sig = a1.sig;
  while (d1.num[d1.l] == 0 && d1.l > 1) --d1.l;
  if (d1.l == 1 && d1.num[1] == 0) d1.sig = 0;
  return d1;
}
bign bigabs(bign a1) {
  a1.sig = 0;
  return a1;
}
void prints(bign a1) {
  if (a1.sig) {
    printf("-");
  }
  for (int i = a1.l; i; --i) {
    printf("%d", a1.num[i]);
  }
}
void scans(bign &a1) {
  char temp[MAXN];
  scanf("%s", &temp);
  a1 = bign(temp);
  if (a1.l == 1 && a1.num[1] == 0) a1.sig = 0;
}
bign biggcd(bign x, bign y) {
  bign zero = bign(0LL);
  while (y != zero) {
    bign t = y;
    y = x % y;
    x = t;
  }
  return x;
}
bign bigpow(bign x, int y) {
  bign ans = bign(1);
  while (y) {
    if (y & 1) ans = ans * x;
    x = x * x;
    y >>= 1;
  }
  return ans;
}
bign bigroot(bign a1, int b1) {
  int pow10 = a1.l % b1 ? a1.l / b1 : a1.l / b1 - 1;
  bign l = bigpow(bign(10), pow10);
  bign r = bigpow(bign(10), pow10 + 1);
  while (l != r) {
    bign mid = (l + r) / bign(2);
    if (bigpow(mid, b1) >= a1) {
      r = mid;
    } else {
      l = mid + bign(1);
    }
  }
  return bigpow(l, b1) <= a1 ? l : l - bign(1);
}
int T;
bign s, a, b, c, small, big, cot;
int main() {
  scans(s);
  scans(a);
  scans(b);
  if (s < a && s < b)
    printf("1/1");
  else {
    if (a == b)
      printf("1/1");
    else {
      if (a > b) {
        c = a;
        a = b;
        b = c;
      }
      small = biggcd(a, b);
      big = a * b / small;
      cot = (s / big) * a - bign(1);
      if (s % big >= a)
        cot = cot + a;
      else
        cot = cot + s % big + bign(1);
      bign ans1 = cot / biggcd(cot, s);
      bign ans2 = s / biggcd(cot, s);
      prints(ans1);
      printf("/");
      prints(ans2);
    }
  }
  return 0;
}
