Vector Willman and Array Bolt are the two most famous athletes of Byteforces. They are going to compete in a race with a distance of L meters today.  Willman and Bolt have exactly the same speed, so when they compete the result is always a tie. That is a problem for the organizers because they want a winner. While watching previous races the organizers have noticed that Willman can perform only steps of length equal to w meters, and Bolt can perform only steps of length equal to b meters. Organizers decided to slightly change the rules of the race. Now, at the end of the racetrack there will be an abyss, and the winner will be declared the athlete, who manages to run farther from the starting point of the the racetrack (which is not the subject to change by any of the athletes). Note that none of the athletes can run infinitely far, as they both will at some moment of time face the point, such that only one step further will cause them to fall in the abyss. In other words, the athlete will not fall into the abyss if the total length of all his steps will be less or equal to the chosen distance L.Since the organizers are very fair, the are going to set the length of the racetrack as an integer chosen randomly and uniformly in range from 1 to t (both are included). What is the probability that Willman and Bolt tie again today?

The first line of the input contains three integers t, w and b (1 ≤ t, w, b ≤ 5·1018) — the maximum possible length of the racetrack, the length of Willman's steps and the length of Bolt's steps respectively.

Print the answer to the problem as an irreducible fraction . Follow the format of the samples output. The fraction  (p and q are integers, and both p ≥ 0 and q > 0 holds) is called irreducible, if there is no such integer d > 1, that both p and q are divisible by d.

NoteIn the first sample Willman and Bolt will tie in case 1, 6 or 7 are chosen as the length of the racetrack.

#include<bits/stdc++.h>
#define ll long long
#define int long long
#define float double
#define sz(c) c.size()
#define fr first
#define sc second
#define pb push_back
#define sz(c) c.size()
#define ppb  pop_back
#define all(a)      (a).begin(),(a).end()
#define rep(i,a,n)   for( int i=a ; i<n ; i++)
#define U 1000000007
#define N 100005
#define ins insert
using namespace std;
signed main()
{
  ios_base::sync_with_stdio(false);
  int t,w,b;
  cin>>t>>w>>b;
  float p=1;
  int xx=__gcd(w,b);
  p=(float)w*b;
  int lcm = p/xx;
  int times=t/lcm;
  int ans=((t/lcm)*min(w,b))+min({t%lcm+1,w,b})-1;
  int gg=__gcd(ans,t);
  ans/=gg;
  t/=gg;
  cout<<ans<<'/'<<t<<endl;
}

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll gcd(ll a,ll b)
{
    return b==0?a:gcd(b,a%b);
}
int main()
{
    ll n,w,b;
    scanf("%I64u%I64u%I64u",&n,&w,&b);
    ll gd=gcd(w,b);
    ll mn=min(w,b);
    ll cd;
    double lcm=(double)w/gd*b;
    if(lcm>n)
        cd=min(mn-1,n);
    else {
        ll cs=n/(ll)lcm;;
        cd=cs*mn+min(mn-1,(n-cs*(ll)lcm));
    }
    ll nn=gcd(cd,n);
    printf("%I64d/%I64d\n",cd/nn,n/nn);
    return 0;
}

#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <iostream>
#include <queue>
#include <map>
#include <bitset>
#include <vector>
using namespace std;
__int64 min(__int64 a,__int64 b)
{
	return a<b?a:b;
}

__int64 gcd(__int64 a,__int64 b){
    if(b==0)
        return a;
	return gcd(b,a%b);
}

int main()
{

__int64		out(__int64 x,__int64 n);

	__int64 n,w,b;
	scanf("%I64d%I64d%I64d",&n,&w,&b);

int ok=0;
	if (w>b) swap(w,b);
	else if (w==b) {printf("1/1\n");return 0;}

		__int64 hh=0;
		__int64 hw=w/gcd(w,b);  //求最小公倍数要除去一个最大公约数。。
		while(hw--)			//用累加来判断是否有乘法溢出
		{
			hh+=b;
			if (hh>n)
			{
				ok=1;
				break;
			}
		}
		if (ok)			//如果会溢出，那么说明最小公倍数都大于长度N,所以 答案必然是 小的w-1或者是n
		{
			__int64 an=min(w-1,n);
			if (an==0) printf("0/1");
			else
			{
				__int64 gd=gcd(an,n);
				printf("%I64d/%I64d\n",an/gd,n/gd);
			}
			return 0;
		}

					//以下情况是没有乘法溢出的
	__int64 gg=b/gcd(w,b)*w;		//lcm
	__int64 tmp=(n)/gg;					//多少个完整的lcm
	__int64 minn=min(w,b);				//取小的那个
	__int64 ans=tmp*(minn);

	__int64 t1=n-tmp*gg;
	__int64 t2=n-tmp*gg;
	__int64 need;
	need=min(t1,t2);
	 if (need>=minn-1)			//如果去掉所有完整的lcm后，剩下的长度为ll   答案为min(ll,minn-1);
	 {
		 ans+=minn-1;
	 }else
		 ans+=need;

	out(ans,n);

	return 0;

}

__int64	 out(__int64 x,__int64 n)
{
	__int64 tmp=gcd(x,n);
	printf("%I64d/%I64d\n",x/tmp,n/tmp);
	return 0;
}

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <vector>
#include <functional>
using namespace std;
struct bign
{
	long long len, s[100];
	bign operator * (const bign& b) const
	{
		bign c;
		memset (c.s, 0, sizeof (c.s));
		c.len = len + b.len - 1;
		for (int i = 1; i <= len; i++)
		for (int j = 1; j <= b.len; j++)
		c.s[i + j - 1] += s[i] * b.s[j];
		for (int i = 1; i < c.len; i++)
		{
			c.s[i + 1] += c.s[i] / 10;
			c.s[i] %= 10;
		}
		while (c.s[c.len] >= 10)
		{
			c.s[c.len + 1] = c.s[c.len] / 10;
			c.s[c.len] %= 10;
			c.len++;
		}
		return c;
	}
	bign operator + (const int& b) const
	{
		bign c;
		c.len = len;
		for (int i = 1; i <= len; i++)
		c.s[i] = s[i];
		c.s[1] += b;
		for (int i = 1; i < c.len; i++)
		{
			c.s[i + 1] += c.s[i] / 10;
			c.s[i] %= 10;
		}
		while (c.s[c.len] >= 10)
		{
			c.s[c.len + 1] = c.s[c.len] / 10;
			c.s[c.len] %= 10;
			c.len++;
		}
		return c;
	}
	bign operator + (const long long& b) const
	{
		bign c;
		c.len = len;
		for (int i = 1; i <= len; i++)
		c.s[i] = s[i];
		c.s[1] += b;
		for (int i = 1; i < c.len; i++)
		{
			c.s[i + 1] += c.s[i] / 10;
			c.s[i] %= 10;
		}
		while (c.s[c.len] >= 10)
		{
			c.s[c.len + 1] = c.s[c.len] / 10;
			c.s[c.len] %= 10;
			c.len++;
		}
		return c;
	}
	bign operator * (const int& b) const
	{
		bign c;
		c.len = len;
		for (int i = 1; i <= len; i++)
		c.s[i] *= b;
		for (int i = 1; i < c.len; i++)
		{
			c.s[i + 1] += c.s[i] / 10;
			c.s[i] %= 10;
		}
		while (c.s[c.len] >= 10)
		{
			c.s[c.len + 1] = c.s[c.len] / 10;
			c.s[c.len] %= 10;
			c.len++;
		}
		return c;
	}
	bign operator * (const long long& b) const
	{
		bign c;
		c.len = len;
		for (int i = 1; i <= len; i++)
		c.s[i] *= b;
		for (int i = 1; i < c.len; i++)
		{
			c.s[i + 1] += c.s[i] / 10;
			c.s[i] %= 10;
		}
		while (c.s[c.len] >= 10)
		{
			c.s[c.len + 1] = c.s[c.len] / 10;
			c.s[c.len] %= 10;
			c.len++;
		}
		return c;
	}
	bign operator + (const bign& b) const
	{
		bign c;
		c.len = max (len, b.len);
		for (int i = 1; i <= c.len; i++)
		c.s[i] = s[i] + b.s[i];
		for (int i = 1; i < c.len; i++)
		{
			c.s[i + 1] += c.s[i] / 10;
			c.s[i] %= 10;
		}
		while (c.s[c.len] >= 10)
		{
			c.s[c.len + 1] = c.s[c.len] / 10;
			c.s[c.len] %= 10;
			c.len++;
		}
		return c;
	}
	bign operator - (const bign& b) const
	{
		bign c;
		c.len = len;
		for (int i = 1; i <= len; i++)
		c.s[i] = s[i] - b.s[i];
		for (int i = 1; i < c.len; i++)
		if (c.s[i] < 0)
		{
			c.s[i + 1]--;
			c.s[i] += 10;
		}
		while (c.s[c.len] == 0)
		c.len--;
		return c;
	}
	bign operator - (const int& b) const
	{
		bign c;
		c.len = len;
		for (int i = 1; i <= len; i++)
		c.s[i] = s[i];
		c.s[1] -= b;
		for (int i = 1; i < c.len; i++)
		while (c.s[i] < 0)
		{
			c.s[i + 1]--;
			c.s[i] += 10;
		}
		while (c.s[c.len] == 0)
		c.len--;
		return c;
	}
	bign operator / (const long long& b) const
	{
		bign c;
		long long now = 0;
		c.len = len;
		for (int i = len; i >= 1; i--)
		{
			c.s[i] = (s[i] + now) / b;
			now = (s[i] + now - c.s[i] * b) * 10;
		}
		while (c.s[c.len] == 0)
		c.len--;
		if (c.len == 0)
		c.len = 1;
		return c;
	}
	bool operator < (const bign& b) const
	{
		if (len != b.len)
		return len < b.len;
		for (int i = len; i >= 1; i--)
		if (s[i] != b.s[i])
		return s[i] < b.s[i];
		return false;
	}
	bool operator == (const bign& b) const
	{
		if (len != b.len)
		return false;
		for (int i = len; i >= 1; i--)
		if (s[i] != b.s[i])
		return false;
		return true;
	}
	void print ()
	{
		for (int i = len; i >= 1; i--)
		printf ("%d", s[i]);
		printf ("\n");
	}
};
inline long long read ()
{
	long long res;
	char ch;
	for (ch = getchar (); ch < '0' || ch > '9'; ch = getchar ());
	res = ch - '0';
	for (ch = getchar (); ch >= '0' && ch <= '9'; ch = getchar ())
	res = res * 10 + ch - '0';
	return res;
}
bign t, b, w, lcm, now, ans, check;
long long b1, w1, t1, g, num, lcm1;
inline long long gcd (long long a, long long b)
{
	return b == 0 ? a : gcd (b, a % b);
}
int main ()
{
	t1 = read();
	w1 = read();
	b1 = read();
	t.len = b.len = w.len = 1;
	t = t + t1;
	w = w + w1;
	b = b + b1;
	lcm = w * b;
	g = gcd (b1, w1);
	lcm = lcm / g;
	now.len = 1;
	lcm1 = w1 * b1;
	check.len = 1;
	lcm1 /= g;
	check = check + lcm1;
	if (check == lcm)
	{
		num = t1 / lcm1 * min (w1, b1) - 1;
		num += min (t1 % lcm1 + 1, min (w1, b1));
	}
	else
	while (now < t || now == t)
	{
		if (now + min (w1, b1) < t || now + min (w1, b1) == t)
		num += min (w1, b1) - 1;
		else
		{
			bign qwer = t - now + 1;
			long long zxc = 0, tat = 1;
			for (int i = 1; i <= qwer.len; i++)
			{
				zxc += qwer.s[i] * tat;
				tat *= 10;
			}
			num += zxc;
			break;
		}
		if (now.len != 1 || now.s[1] != 0 || w1 == b1)
		num++;
		now = now + lcm;
	}
	if (num > t1)
	num = t1;
	g = gcd (t1, num);
	printf ("%I64d/%I64d\n", num / g, t1 / g);
	return 0;
}

#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ull;

ull gcd(ull l, ull r){
    if (r == 0) return l;
    else gcd(r, l%r);
}

int main(){
   // freopen("input.txt", "r", stdin);
    ull l, w, b;  cin >> l >> w >> b;
    ull g = gcd(w, b);
    ull m = min(w, b);

    ull min_fac = w / g * 1. * b < 1e19 ? w / g * b : (ull)1e19;
    ull prev = l/min_fac*m - 1;
    prev = prev + min((l%min_fac)+1, m);
    ull rgcd = gcd(prev, l);
    prev /= rgcd;
    l /= rgcd;

    cout << prev << "/" << l;

    return 0;
}

#include<iostream>
#include<algorithm>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<string>
#include<stdio.h>
using namespace std;
typedef long long LL;
LL Gcd(LL a,LL b){
    while (a%b!=0){
        LL c=a;
        a=b;
        b=c%a;
    }
    return b;
}
int main(){
    LL a,b,T;
    cin>>T>>a>>b;
    LL M=Gcd(a,b);
    long double ex=a*1./M*b;
    LL num,G=a/M*b;
    if (ex>T*1.) G=T+1;
    num=T/G+1;
    LL ans=num*min(a,b)-1;
    if (T%G<min(a,b)-1) ans+=T%G-min(a,b)+1;
    M=Gcd(ans,T);
    T/=M;
    ans/=M;
    cout<<ans<<'/'<<T<<endl;
    return 0;
}

#include<iostream>
#include<algorithm>
using namespace std;
long long int mdc(long long int a,long long int b)
{
  if(b==0) return a;
  else return mdc(b,a%b);
}
void divisivel(long long int as,long long int t)
{
  long long int x=mdc(as,t);
  if(as==t)
  {
    cout<<"1/1"<<endl;
    return;
  }
  while(x!=1)
  {
    as=as/x;
    t=t/x;
    x=mdc(as,t);

  }
  cout<<as<<"/"<<t<<endl;
}
int main()
{
  long long int  t,w,b;
  cin>>t>>w>>b;
  if(t<w and t<b)
  {
    cout<<"1/1"<<endl;
    return 0;

  }
  if(w>10000000000 and b>1000000000 and mdc(w,b)<=1000)
  {
    if(w<=t or b<=t)
    {
      divisivel(min(w,b)-1,t);
      return 0;
    }
  }
  long long int xablau=mdc(w,b);
  xablau=w/xablau;
  xablau=xablau*b;
//  cout<<xablau<<endl;
  long long int n_mdc=t/xablau;
//  cout<<n_mdc<<endl;
  long long int faixa=0;
  long long int aux=0;
  long long int as=0;
  if(w!=b)
  {
    faixa=min(w,b);
  }
  else if(w==b)
  {
    cout<<"1/1"<<endl;
    return 0;
  }
  if(xablau*n_mdc + faixa >t)
  {
    //  cout<<"oi";
    aux=t-(xablau*(n_mdc)+faixa);
//    cout<<aux<<endl;
    if(aux>=min(w,b)) aux=min(w,b);
    if(faixa!=0 and n_mdc!=0)
    as= (n_mdc)*(faixa)+faixa+aux;
    else if(faixa!=0 and n_mdc==0)
    {
      as=aux;
    }
    else as=n_mdc;
  }
  else
  {
//    cout<<n_mdc<<endl<<faixa<<endl;
     as= (n_mdc)*(faixa)+faixa-1;
  }
  divisivel(as,t);

  return 0;
}

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<map>
#include<vector>
#include<set>
#include<queue>
#include<algorithm>
#include<stack>
#include<cstdlib>
#include<deque>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int>P;
const int len=1e4+10;
const ll mod=100003;
int main()
{

    ll n,a,b;
    cin>>n>>a>>b;
    ll s=n/a*__gcd(a,b)/b*min(a,b);
	ll y=n-n/a*__gcd(a,b)/b*b/__gcd(a,b)*a;
	y++;
	s+=min(min(a,b),y)-1;
	cout<<s/__gcd(s,n)<<"/"<<n/__gcd(s,n)<<endl;
}

#pragma comment(linker, "/STACK:250000000")
#define _USE_MATH_DEFINES
#define ll long long
#define Inf 2147483000
#define For(i, n) for(int i = 0; i < n; ++i)

#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <string>

using namespace std;

class leg {
public:
  int length, energy;
  bool operator < (leg another) {
    return length < another.length;
  }
};

long long gcd( long long a, long long b) {
  if (b == 0) return a;
  return gcd(b, a%b);
}

//class Solution {
//    vector<vector<string>> mem;
//    vector<int> visit;
//    void DFS(string& s, unordered_set<string>& wordDict, int pos) {
//        visit[pos] = 1;
//        for (int i = pos + 1; i <= s.size(); ++i) {
//            if (wordDict.find(s.substr(pos, i - pos)) != wordDict.end()) {
//                if (i == s.size()) {
//                    mem[pos].push_back(s.substr(pos, i - pos));
//                    continue;
//                }
//                if (!visit[i])
//                    DFS(s, wordDict, i);
//                for (auto& str : mem[i])
//                    mem[pos].push_back(s.substr(pos, i - pos) + " " + str);
//            }
//        }
//    }
//
//public:
//    vector<string> wordBreak(string s, unordered_set<string>& wordDict) {
//        visit.resize(s.size());
//        mem.resize(s.size());
//        DFS(s, wordDict, 0);
//        vector<string> answ = mem[0];
//        mem.clear();
//        visit.clear();
//        return answ;
//    }
//};

int main() {
  ios_base::sync_with_stdio(false);

  const long long Mod = 1e9+7;
  unsigned long long n, k, m, answer, t, w, b;
  cin >> t >> w >> b;
  unsigned long long d = gcd(w, b);
  if (w > b) {
	  swap(w, b);
  }
  b = b / d;
  unsigned long long times = 1, r = 0;
  times = t / w / b;
  r = t;
  if (times > 0) {
	  r = t - times * w * b;
  }
  answer = w * times - 1;
  answer += min(w, r + 1);
  d = gcd(answer, t);
  answer /= d;
  t /= d;

  cout << answer << "/" << t << endl;

  return 0;
}

#include <bits/stdc++.h>
#define ll long long
#define fop(i,m,n) for(int i=m; i<n; i++)
#define fastIO ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define X first
#define Y second
#define pb push_back
#define mp make_pair

using namespace std;

const long long MOD = 998244353;
const long long N = 1e9+5;
const long long Hash = 31;
const double pi = 3.141592653;
const double E = 2.718281828;

ll gcd(ll a, ll b){
    if(b == 0) return a;
    return gcd(b, a%b);
}

ll lcm(ll a, ll b){
    return (a/gcd(a, b))*b;
}

void solve(){

    ll t, w, b;
    cin >> t >> w >> b;
    if(w<b) swap(w, b);

    ll x = lcm(w, b);
    if(x<=0 || x%w || x%b){
        ll a = min(t, b-1);
        cout << a/gcd(a, t) << "/" << t/gcd(a, t);
        return;
    }
    ll n = t/x;
    ll ans = min(b, t%x+1);
    ans += n*b;
    ans--;

    cout << ans/gcd(ans, t) << "/" << t/gcd(ans, t);

}

int main()
{
    fastIO;

    int t=1;
    //cin >> t;
    while(t--) solve();

    return 0;
}

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <bitset>
#include <stack>
#include <deque>
#include <iterator>
#include <tuple>
#include <iomanip>
#include <valarray>
#include <limits>
#include <sstream>
#include <cassert>
#include <functional>
#include <numeric>
#define in insert
#define pb push_back
#define mp make_pair
#define int long long
#define fi first
#define double long double
#define se second
#define endl '\n'
#define pii pair<int,int>
#define pdd pair<double,double>
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);
#define mod 1000000007
#define MAXN  2
using namespace std;
int spf[MAXN];
int fac[MAXN];
void sieve()//sieve
{
    spf[1] = 1;
    for (int i=2; i<MAXN; i++)
        spf[i] = i;
    for (int i=4; i<MAXN; i+=2)
        spf[i] = 2;
    for (int i=3; i*i<MAXN; i++)
    {
        if (spf[i]==i)
        {
            for (int j=i*i; j<MAXN; j+=i)
                if (spf[j]==j)
                    spf[j]=i;
        }
    }
}//sieve ends
map<int,int> getfactor(int a)//factor prime
{
    map<int,int> m;
    while(a>1)
    {
        m[spf[a]]++;
        a/=spf[a];
    }
    return m;
}//prime factor ends
int power(int x,int y,int p)
{
    int res = 1;
    x = x ;//% p;
    if (x == 0) return 0;
    while (y > 0)
    {
        if (y & 1)
            res = (res*x);//% p;
        y = y>>1;
        x = (x*x) ;//%p;
    }
    return res;
}
int gcd(int a, int b)
{
    if (a == 0)
        return b;
    return gcd(b % a, a);
}
int inverse(int a, int p)
{
    return power(a, p-2, p);
}
int ncr(int n, int r, int p)
{
    if (r==0)
        return 1;
    return (fac[n]*inverse(fac[r], p) % p *
            inverse(fac[n-r], p) % p) % p;
}
void solve()
{
    int t,w,b;
    cin>>t>>w>>b;
    int lcm=(w)/gcd(w,b);
    if(6e18/b<=lcm)
        lcm=6e18;
    else lcm*=b;
    int k=t/lcm;
    int ans=0;
    ans+=k;
    ans+=k*(min(w,b)-1);
    int rem=t%lcm;
    ans+=min(rem,(min(w,b)-1));
    int g=gcd(ans,t);
    ans/=g;
    t/=g;
    cout<<ans<<"/"<<t<<endl;
}
signed main()
{
    fast
    int t=1;
    //cin>>t;
    while(t--)
    {
        solve();
    }
}

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef vector<int> vi;
typedef pair<int,int> ii;
typedef vector<vector<int> > vvi;
typedef vector<vector<ii> > vvii;

#define pb push_back
#define mp make_pair
#define all(x) x.begin(),x.end()
#define sz(x) (int)x.size()
#define fill(a,x) memset(a,x,sizeof(a))
#define F first
#define S second
#define trav(a, x) for(auto& a : x)
#define FOR(i,a,b) for(int i = a; i<=b; ++i)
#define NFOR(i,a,b) for(int i = a; i>=b; --i)
#define fast ios_base::sync_with_stdio(false),cin.tie(0),cout.tie(0)
const ll INF = 1e18;
const int mod = 1e9+7;
const int N = 1e5 + 10;
inline int add(int x,int y){
  x += y;
  if(x >= mod) x -= mod;
  return x;
}
inline int mul(int x,int y){
  x = (1LL * x * y) % mod;
  return x;
}

ll gcd(ll a,ll b)
{
	if(b==0)return a;
	else return gcd(b,a%b);
}

int val(ll a,ll b,int *d1,int *d2)
{
	int c = 0;
	while(a>0)
	{
		*d1 =  a%10;
		a = a/10;
		c++;
	}

	while(b >0)
	{
		*d2 = b%10;
		b = b/10;
		c++;
	}

	return c-2;
}

int main()
{
    fast;
    ll t,w,b;
    cin>>t>>w>>b;
    if(w==b)
    {
    	cout << 1 << "/" << 1 << "\n";
    	return 0;
    }
    int d1,d2;
    ll e = val(w/gcd(w,b) , b ,&d1,&d2);
    int f = 0;
    int h = d1*d2;
    ll d = min(w,b);
    while(h > 0)
    {
    	f++;
    	h = h/10;
    }
    if(e + f-1 >= 19)
    {
    	ll d1 = min(d-1,t);
    	ll g  = gcd(t,d1);
    	t = t/g;
    	d1 = d1/g;
    	cout << d1 << "/" << t << "\n";
    	return 0;
    }
    else
    {
    	ll lcm = (w/gcd(w,b))*(b);
	    ll p = t/lcm;
	    ll ans = 0;
	    ans += p * d;
	    ans += min(t - p*lcm + 1 , d);
	    ans--;
	    ll g = gcd(t,ans);
	    t = t/g;
	    ans = ans/g;
	    cout << ans << "/" << t << "\n";
	}
    return 0;
}

#include <vector>
#include <list>
#include <map>
#include <math.h>
#include <cmath>
#include <set>
#include <queue>
#include <deque>
#include <string>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <string.h>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <ctime>

#define ll long long int
#define ull  unsigned long long int
#define ld long double
using namespace std;
ull GCD(ull a, ull b)
{
	if (b < a)
		swap(a, b);
	if (a == 0)
		return b;
	return GCD(a, b%a);
}
ull LCM(ull a, ull b)
{
	ull ret = GCD(a, b);
	ret = a / ret;
	ret *= b;
	return ret;
}
int main()
{
	ios::sync_with_stdio(false);
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr), cout.tie(nullptr);
	//freopen("output.txt", "w", stdout);
	//freopen("input.txt", "r", stdin);
	ull l, b, a, answer;
	cin >> l >> a >> b;
	ull lcm = LCM(a, b);
	ull gogo = l / a*GCD(a, b) / b;
	if (a / GCD(a, b) > l / b)
		answer = min(l, min(a, b) - 1);
	else
		answer = (l / lcm)*min(a, b) + min(min(a - 1, b - 1), l - (l / lcm)*lcm);
	ull g = GCD(l, answer);
	cout <<answer/g<<"/"<<l/g<< endl;
	return 0;
}

//Bismillahir Rahmanir Rahim
#include<cstdio>
#include<cstring>
#include<cmath>
#include<cctype>
#include<cassert>
#include<cstdlib>
#include<iostream>
#include<iomanip>
#include<string>
#include<sstream>
#include<algorithm>
#include<vector>
#include<stack>
#include<list>
#include<queue>
#include<set>
#include<map>
#include<utility>
#include<bitset>
#include<ctime>
using namespace std;

#define i64 long long int
#define u64 unsigned long long int

#define fin(a) freopen(a,"r",stdin)
#define fout(a) freopen(a,"w",stdout)

#define repc(i,a,b) for(__typeof(b) i=(a); i<=(b); i++)
#define repr(i,a,b) for(__typeof(b) i=(a); i>=(b); i--)

#define clr(a) a.clear()
#define sz(a) (int)a.size()
#define mem(a,b) memset(a,b,sizeof a)
#define ERASE(a) a.erase(a.begin(),a.end())

#define sc scanf
#define S(z) scanf("%d",&z)
#define SL(z) scanf("%I64d",&z)
#define S2(xx,zz) scanf("%d %d",&xx,&zz)
#define SL2(xx,zz) scanf("%I64d %I64d",&xx,&zz)
#define SC(z) scanf("%s",&z)

#define pf printf
#define pfn printf("\n")
#define PF(z) printf("%d",z)
#define PFL(z) printf("%I64d",z)
#define PF2(x,y) printf("%d %d",x,y)
#define PFL(z) printf("%I64d",z)
#define PFS(z) printf("%s",z)

#define ff first
#define ss second
#define mp make_pair

#define MI map<int,int>
#define MSI map<string,int>
#define MIS map<int,string>
#define SI set<int>
#define SS set<string>
#define SMI multiset<int>
#define VI vector<int>
#define VI2 vector < vector < int > >
#define QU queue<int>
#define PQU priority_queue<int>
#define STK stack<int>
#define pb push_back

#define inf 100000007LL
#define pi  acos(-1.0)
#define MAX 200007
#define MOD 1000000007
#define eps 1e-9

template <class T>T sqr(T x) {return x*x;}
template< class T > T gcd(T a, T b) { return (b != 0 ? gcd<T>(b, a%b) : a); }
template< class T > T lcm(T a, T b) { return (a / gcd<T>(a, b) * b); }
template <class T> inline T bigmod(T p,T e,T M)
{
    if(e==0) return 1;
    if(e%2==0){i64 t=bigmod(p,e/2,M);return (T)((t*t)%M);}
    return (T)((i64)bigmod(p,e-1,M)*(i64)p)%M;
}
template <class T> inline T bigexp(T p,T e)
{
    if(e==0)return 1;
    if(e%2==0){i64 t=bigexp(p,e/2);return (T)((t*t));}
    return (T)((i64)bigexp(p,e-1)*(i64)p);
}
template <class T> inline T modinverse(T a,T M){return bigmod(a,M-2,M);}

int dx4[]={1,0,-1,0};int dy4[]={0,1,0,-1}; //4 Direction
int dx8[]={1,1,0,-1,-1,-1,0,1};int dy8[]={0,1,1,1,0,-1,-1,-1};//8 direction
int month[]={31,28,31,30,31,30,31,31,30,31,30,31};
/*
struct Graph
{
    int u,v,w;
    bool operator<(const Graph& p)
    const {return w<p.w;} // oporerta chotor jnne
}edge[10];
struct compare
{
    bool operator()(const int&l,const int&r)
    {
        return l>r;
    }
};
priority_queue<int,vector<int>,compare>pq;
*/
/******************* Code Starts here *******************/

i64 t,a,b,c,d,g,res,p;

int main()
{
    sc("%I64d %I64d %I64d",&t,&a,&b);
    if(a>b) swap(a,b);
    c=a;
    g=lcm(a,b);
    if(t<b || g<=0 || g>t || g%a!=0 || g%b!=0)
    {
        res=c-1;
       if(t<a) res=t;
       else if(t<b) res;
       else if(a==b || g==b ) res+=1;
    }
    else
    {
    c--;
    res+=c;
    if(t%g==0)
    {
       d=t/g;
           res+=d;
           if(d>0) d--;
           d*=c;
           res+=d;
    }
    else
    {
       d=t/g;
       p=t-(g*d);
           res+=d;
           if(d>0) d--;
           d*=c;
           res+=d;
       c=min(c,p);
       res+=c;
    }
    }
    g=gcd(res,t);
    if(g==1)
        pf("%I64d/%I64d",res,t);
    else
    {
        res=res/g;
        t=t/g;
        pf("%I64d/%I64d",res,t);
    }
    return 0;
}

#include <bits/stdc++.h>

using namespace std;

typedef long long int64;
typedef pair<int64, int64> frac;
#define mp make_pair
#define num first
#define denom second

int64 lcm(int64 a, int64 b) {
  if((double)a/__gcd(a,b)*b > 5*1e18) return -1;
  return a/__gcd(a,b)*b;
}

inline int64 plafon(int64 a, int64 b) {
  return a/b + !!(a%b);
}

inline int64 pod(int64 a, int64 b) {
  return a/b;
}

frac reduce(frac x) {
  int64 GCD = __gcd(x.num, x.denom);
  return mp(x.num/GCD, x.denom/GCD);
}

int main() {
  int64 t, w, b; cin >> t >> w >> b;
  int64 mini = min(w, b);
  int64 LCM = lcm(w, b);
  frac sol;
  if (LCM == -1) {
    sol = mp(min(mini-1, t), t);
  } else {
    int64 nom = plafon(t, LCM) * (mini-1) + pod(t, LCM);
    int64 cap;
    if (t == pod(t,LCM)*LCM) cap = (pod(t,LCM)-1) * LCM + mini - 1;
    else cap = pod(t, LCM) * LCM + mini - 1;
    if (t < cap) nom -= cap - t;
    sol = mp(nom, t);
  }
  sol = reduce(sol);
  cout << sol.num << "/" << sol.denom << endl;
  return 0;
}

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <cmath>
#include <map>
#include <stdlib.h>
#include <ctype.h>
#include <string>
#include <string.h>
    using namespace std;

#define ll long long

ll t;
ll gcd(ll a, ll b)
{
    if(b==0)
        return a;
    return gcd(b,a%b);
}

ll lcm(ll a,ll b)
{
    ll z = gcd(a,b);
    if(((long double)t/b *z) < a)
        return 0;
    return a/z*b;

}
int main ()
{
    //freopen("input.txt","r",stdin);
    ll w,b,x,y,z=0;
    cin>>t>>w>>b;

    if(b==w || (b>t && w>t))
    {
        cout<<"1/1"<<endl;
        return 0;
    }

    if(b>w)
        swap(w,b);
    x = lcm(b,w); //LCM
    if(!x)
    {
        cout<<(b-1)/gcd(b-1,t)<<"/"<<t/gcd(b-1,t)<<endl;
        return 0;
    }
    y = t/x; //LCM*numberof times

    ll ans = y*b;
    ans += min(b-1,t%x);
    ll div = gcd(t,ans);

    cout<<(ans/div)<<"/"<<(t/div)<<endl;

    return 0;
}

#include <bits/stdc++.h>
#define ll long long
#define fr first
#define sc second
using namespace std;

const ll N = (ll) 3e5 + 10;

string s[N];
void out(ll p,ll q){
    ll g = __gcd(p,q);
    p/=g;
    q/=g;
    cout << p << "/" << q << endl;
    exit(0);
}
ll gcd(ll a,ll b){
    return a ? gcd(b%a,a) : b;
}
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
#ifdef LOCAL
    freopen("in.in","r",stdin);
#endif
    ll a, b , c;
    cin >> a >> b >> c;
    if(b > c)swap(b,c);
    ll g = gcd(b,c);
    if(b / g > a / c ) out(min(a,b - 1),a);
    ll l = (b / g) * c;
    ll v = a/l ;
    ll p = v * min(b,c) + min(a % l + 1, b) - 1;
    out(p,a);
}

#include <iostream>
#include <cstdio>
#include <fstream>
#include <cmath>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <stack>
#include <vector>
#include <algorithm>
#include <queue>

#define F first
#define S second
#define x1 privet1
#define x2 privet2
#define y1 privet3
#define y2 privet4
#define hash privet5

using namespace std;

    const long long inf=5e18;

    long long n, a, b;

    void gcd(long long d){
        long long g = n, h = d;
        while(g!=0 && h!=0)if(g>h) g%=h; else h%=g;
        long long j = max(g, h);
        //cout << d << " " << d/j << " " << j << "\n";
        cout << d/j << "/" << n/j;
    }

    long long gcd(long long a, long long b){
        while(a!=0 && b!=0)if(a>b) a%=b; else b%=a;
        return max(a, b);
    }

int main(){
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    cin >> n >> a >> b;
    long long g = gcd(a, b);
    if(a == b){cout << "1/1"; return 0;}
    if(b>a) swap(a, b);
    if(a/g > inf/b) {gcd(min(b-1, n)); return 0;}
    //cout << (double)n/(double)a << "\n";
    long long ans=0, nok = a/g*b;
    if(n<nok){gcd(min(n, b-1)); return 0;}
    ans = (n/nok)*b;
    ///cout << g << "\n";
    //cout << b-1 << " " << n-(long long)(0.5+l*a/g*b) << "\n";
    //cout << ans << " ";
    ans+=min(b-1, n%nok);
    //cout << ans << "\n";
    gcd(ans);//if(l <= 1) gcd(ans); else gcd(ans-1);
    return 0;

}

/**********************************************************
 *     Code written by Akikaze                            *
 *     Duy-Bach Le, #Team4T's Chief Executor              *
 *     #Team4T Tertiary Flagship - Oblivion               *
 *                                                        *
 *     Written by a random fan of momocashew and Chiho    *
 *                                                        *
 *     Arigatougozaimasu, imouto-chan.                    *
 **********************************************************/

/************** [OPTIMIZATION PROTOCOL] **************/
#pragma comment(linker, "/stack:225450978")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
/*****************************************************/

/************** [LIBRARY PROTOCOL] **************/
#include <bits/stdc++.h>
using namespace std;
/************************************************/

/************** [LEGENDS/CONSTANTS] **************/
#define endl '\n'
#define i64 long long
#define ld long double
#define rsz resize
#define pub push_back
#define mp make_pair
#define fi first
#define se second
typedef vector<i64> vi;
typedef vector<ld> vd;
typedef vector<string> vs;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef pair<i64, i64> pii;
typedef pair<i64, pii> pip;
typedef pair<pii, i64> ppi;
const long long Mod = 1000000007LL, INF = 1e9, LINF = 1e18;
const long double Pi = 3.141592653589793116, EPS = 1e-9, Gold = ((1+sqrt(5))/2);
long long keymod[] = {1000000007LL, 1000000009LL, 1000000021LL, 1000000033LL};
long long keyCount = sizeof(keymod) / sizeof(long long);
/*************************************************/

/************** [BITWISE FUNCTIONS] **************/
template<class T> int getbit(T s, int i) { return (s >> i) & 1; }
template<class T> T onbit(T s, int i) { return s | (T(1) << i); }
template<class T> T offbit(T s, int i) { return s & (~(T(1) << i)); }
template<class T> int cntbit(T s) { return __builtin_popcountll(s); }
/*************************************************/

/************** [MASTER CONTROLS - PHASE 1] **************/
auto TimeStart = chrono::steady_clock::now();
auto TimeEnd = chrono::steady_clock::now();
#define OImode 227420978
#define MultiTest 227420978

#undef OImode // Switch this off if submitting OI problems.
#undef MultiTest // Switch this off if submitting multi-test problems.

void ControlIO(int argc, char* argv[]);
void TimerStart();
void TimerStop();
void Exit();
/*********************************************************/

/************** [GLOBAL VARIABLES] **************/
i64 t, w, b;
/************************************************/

/************** [FUNCTIONS] **************/
i64 LCM(i64 a, i64 b) {
	i64 GCD = __gcd(a, b); a /= GCD;
	if (a <= t / b) return (a * b);
	return -1;
}

void Input() {
	cin >> t >> w >> b;
}

void Solve() {
	i64 m = LCM(w, b);
	if (m == -1) {
		i64 p = min(min(w, b) - 1, t), q = t;
		i64 g = __gcd(p, q); p /= g; q /= g;
		cout << p << "/" << q; return;
	}
	i64 maximum = t - t % m, occ = t / m + 1;
	i64 subtract = 1;
	subtract += max((maximum + min(w, b) - 1) - t, 0LL);
	i64 p = occ * min(w, b) - subtract, q = t;
	i64 g = __gcd(p, q); p /= g; q /= g;
	cout << p << "/" << q;
}
/*****************************************/

/************** [MAIN] **************/
int main(int argc, char* argv[]) {
	ControlIO(argc, argv);
	ios_base::sync_with_stdio(0); cin.tie(NULL);
	#ifndef MultiTest
		Input(); TimerStart();
		Solve(); TimerStop();
	#else
		int T; cin >> T; TimerStart();
		while(T--) {Input(); Solve();}
		TimerStop();
	#endif
	return 0;
}
/************************************/

/************** [MASTER CONTROLS - PHASE 2] **************/
void ControlIO(int argc, char* argv[]) {
	#ifdef Akikaze
	time_t t = time(0);
	tm* now = localtime(&t);
	cout << "Source code by #Team4T-Akikaze.\n";
	cout << "Current time: ";
	cout << (now->tm_year + 1900) << '-'
	     << (now->tm_mon + 1) << '-'
	     <<  now->tm_mday << " | "
	     <<  now->tm_hour << ":"
	     <<  now->tm_min << ":"
	     <<  now->tm_sec
	     << "\n\n";
	if (argc > 1) assert(freopen(argv[1], "r", stdin));
	if (argc > 2) assert(freopen(argv[2], "w", stdout));
	#elif OImode
	freopen("FILENAME.INP", "r", stdin);
	freopen("FILENAME.OUT", "w", stdout);
	#endif
}

void TimerStart() {
	#ifdef Akikaze
	TimeStart = chrono::steady_clock::now();
	#endif
}

void TimerStop() {
	#ifdef Akikaze
	TimeEnd = chrono::steady_clock::now();
	auto ElapsedTime = TimeEnd - TimeStart;
	cout << "\n\nTime elapsed: " << chrono::duration<double>(ElapsedTime).count() << " seconds.\n";
	#endif
}

void Exit() {
	TimerStop(); exit(0);
}
/*********************************************************/

/*********************************************************************************************************************************************************************************************************
 * ti;.                               .:,:i:         :,;;itt;.        fDDEDDEEEEEEKEEEEEKEEEEEEEEEEEEEEEEE###WKKKKKKKKKKKKKKKKKKKKWWWWWWWWWWWWWWWWWWW#WWWWWKKKKKEE      :,:.    f::::. .,ijLGDDDDDDDEEEEEEE*
 *ti;.                               .:,:i:          .:,;itt;:      GLDEEGEEEEEEEEEEEEEEEEEEDEEEEEEEEEEE#W#WEKKKKKKKKKKKKKKKKKKKKKKKWWWWWWWWWWWWWWWWWWWWWWKKKKKKG.     .::.      f:,...,ijLGDDDDDDDDEEEEEE *
 *ti;.                               .:,:i:            :,;;iti,    :fDDEEEEEEEEEEEEEEEKEEEEDEEEEEEEEEEEW##WEEEKKKKKKKKKKKKKKKKKKKKKWWWWWWWWWWWWWWWWWWWWWWWKKKKKKEG     .::.       .f,::,ijLGDDDDDDDDEEEEEE *
 *ti;.                               .:,:i:             .,,;iti;.  LDDEEEEEEEEEEKEEEEWEEEDDEEEEEEEEEEE#WWWEEEEEKKKKKKKKKKKKKKKKKKKKKKKKKWWWWWWWWWWWWWWWWWWWKKKKKEDj    .::.        .:L;;ijfGDDDDDDDDDEEEEE *
 *ti;.                               .:,:i:              .:,;;iii:LLDEEEEEEEEEEEKEEEEEEEEDEEEEEEEEEEEW#WWEEEEEEEKKKKKKKKKKKKKKKKKKKKKKKKKWWKWWWWWWWWWWWWWWKKKKKKKEL    .::.         .:;LijLGGDDDDDDDDEEEEE *
 *ti;.                               .:,:;:                :,;;ittfDEEEEEEEEEEEEEEEEKEEEGEEEEEEEEEEEKWWWEEEEEEEEEKKKKKKKKKKKKKKKKKKKKKKKKKKWWWWWWWWWWWWWWWKKKKKKKELj   .::.          :,;jffGGDDDDDDDDDEEEE *
 *ti;.                               .:,:i:                 .,;;tGGDEEEEEEEEEEEKEEEKEEEDEEEEEEEEEEEEWWWEEEEEEEEEEEEKKKKKKKKKKKKKKKKKKKKKKKKKKWWWWWWKWWWWWWKKKKKKKEEL   .::.          .:;itDGGDDDDDDDDDEEEE *
 *ti;.                               .:::;:                   :;ifDEEEEEEEEEEEEKEEEKEEEEEEEEEEEEEEEWWWEEEEEEEEEEEEEEKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKW#WWWKKKKKKKKEEf   .::.           :,itfGEDDDDDDDDDDDEE *
 *ti;.                               .:::;:                    :GGEEEEEEEEEEEKEKEEKEEEEEEEEEEEEEEEEWWEEEEEEEEEEEEEEEEEKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKW#WKKKKKKKKKEEDG  .::.           .,;jfLGKDLDDDDDDEEDD *
 *ti;.                               .:::;:                     fDEEEEEEKKKKKKKKKEKEEEEEEEEEEEEEEE#WEEEEEEEEEEEEEEEEEEKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKW#KKKKKKKKKKEEf .:::.           .,;tfLGDEDDDDDDDDEEE *
 *ti;.                                :::;:                    fDEEEEEEKKKKKKKKKKWKEEEEEEEEEEEEEEEWKEEEEEEEEEEEEEEEEEEEEKEKKKKKKKKKKKKKKKKKKKKKKKKKKKKW##KKKKKKKKKEEft :::.           .,;tfLGDDDKDDDDDDDDD *
 *ti;.                                .::;:                    fDEEEEEEKKKKKKKWKKKKKEEEEEEEEEEEEE#WEEWEEEEEDEEDEEEEEEEEEEEEKKKKKKKKKKKKKKKKKKKKKKKKKKKKW#WKKKKKKKKEEGG :,:.           .,;tfLGGDDDKDDDDDDDD *
 *ti;.                                .:.;:                   tGDEEEEKKKKKKKKKKKKKKKKKEEEEEEEEEEEWEEKWEEEEEEEDEEEEEEEEEEEEEEKEKKKKKKKKKKKKKKKKKKKKKKKKKKWWWKKKKKKKEEDf :::.           .,;tfLGGDDDDEDDDDDDD *
 *ti;.                                .::;:                   fDEEEEEKKKKKKKKKKKWKKKKKKKKEEEEEEEWWEEWEEEEEEEEEEEEEEEEEEEEEEEEEEKKKKKKKKKKKKKKKKKKKKKKKKKW##KKKKKKKEEEft.::.           .,;tfLGGDDDDDDEDDDDD *
 *ti;.                                .:.;:                  tGDEEEKKKKKKKKKKKKKKKKKKKKKKEKEEEEE#EEWWEEEEEEEEEEEEEEEEEEEEEEEEEEEEKKKKKKKKKKKKKKKKKKKKKKKKW#WKKKKKKEEEGD:::.           .,;tfLGGDDDDDDDEDDDD *
 *ti;.                                .:.,.                  LDEEEEKKKKKKKKKKWKWKKKKKKKKKKKKEEEKWEKW#EEEEEEEEEEEEEEEEKEEEEEEEEEEEEEEEKKKKKKKKKKKKKKKKKKKKW##KKKKKKEEEEf,,:.           .,;tfLGGDDDDDDDDEDDD *
 *ti;.                               ..:.,.                 LGDEEEEKKKKKKKKKKWKKKKKKKKKKKKKKKKKWEEW#WEEEEEEEEEEEEEEEKEEEEEEEEEEEEEEEEEEEKEKKKKKKKKKKKKKKKK##KKKKKEEEEEfi;,.           .,;tfLGGDDDDDDDDDKDD *
 *tt;.                                .:.,:                 jDEEEEKKKKKKKKKKWWKKKKKKKKKKKKKKKKKWKE#WWEEEEEEEEEEEEEEWEEEEEEEEEEEEEEEEEEEEEEEKKKKKKKKKKKKKKKKWWKKKKEEEEDfG;,:           .,;tfLGGDDDDDDDDDDKD *
 *tii,.                               .:.,.                tGDEEEEKKKKKKKKKKWWWKKKKKKKKKKKKKKKWKKWWWKEEEEEEEEEEEEEKEEEEEEEEEEEEEEEEEEEEEEEEEEEEEKKKKKKKKKKKW#KKKKEEEEDGGi;,.          .,;tfLGGDDDDDDDDDDDE *
 *ti;;,:.                             .:.,:                fDEEEEKKKKKKKKKKKWKKKKKKKKKKKKKKKKKWEK#WWKEEEEEEEEEEEEDEEEEEEEEEEEEEEGEEEEEEEEEEEEEEEEEEEKKKKKKKWWKKEEEEEEDDf;;;,.         .,;tfLGGDDDDDDDDDDDD *
 *tii;,,:..                           ...,.               ;LEEEEEKKKKKKWKKKKWKKKKKKKKKKKKKKKKKEKKW#WEEEEEEEEEEEEEjEEEEEEEEEKEEEEGEEEEEEEEEKEEEEEEEEEEEEEEEEE#WKEEEEEEDDf;;;;,:        .,itfLGGDDDDDDDDDDDD *
 *ti;,,,,,:.                          ...,.               LDEEEEKKKKKKKKKKKWWWKKKKKKKKKKKKKKKWKK#W#WEEEEEEEEEEEDDLEEEEEEEEEWEEEEDEEEEEEEEEKEEEEEEEEEEEEEEEEEWWEEEEEEEDDfj,,,,,:.      .,itfGGGDDDDDDDDDDDD *
 *tii,,,,::::.                        ...,:              .fDEEEEKKKKKKWKKKKWWWKKKKKKKKKKKKKKKEKKW#WWEEEEEEEEEEEKiKEEKEEEEEEWEEEEDEEEEEEEEEEEEEEEEEEEEEEEEEEEWWEEEEEEEDDLD:::,,,:.     .,ijfGGGDDDDDDDDDDDD *
 *ti;:::::::::..                      .:.,:              LDEEEEKKKKKKKWKKKKWWKKKKKKKKKKKKKKKKtKKWWWWKEEEEEEEEEDiiDEEEEEEEEWWEEEEEEDEEEEEEEEEEEEEEEEEEEEEEEEEEWKEEEEEDDDGL:. .:,,,:    .,ijLGGGDDDDDDDDDDDD *
 *tt;. .::::::::..                    ...,:             :fDEEEKKKKKKKKKKKKWW#KKKKKKKKKKKKKKKKfKKWWWWKEEEEEEEEDti,DEKEEEEEEWWEEEDEEEEEEEEEKEEEEEEEEEEEEEDEEEEE#WEEEEEGGDGf:.  .:,;,:.  .,ijLGGDDDDDDDDDDDDD *
 *tt;.   .:::::::..                   ...,:             GDEEEKKKKKKKKWKKKKWWWKKKWKKKKKKKWWWKDEKLWWWWKKEEEEEEDEi,LDEEEEEEEEWWEEEEEEEEEEEEEEEEEEEEEEEEEDEDEEEEEW#EEEEDDDDGf,.    :,,,:...,ijLGGGDDDDDDDDDDDD *
 *tt;.    .....::::..                 ...,:             fDEEEKKKKKKKKWKKKKWWWWKKKWKKKKKKKKKKfWKiWWW#KKEEEEEEEi;.EDfEEEDEEiWWEEEEEEEEEEEEDGKEEEEEEEEEEDEEEEEEEWWEEEEDDDGGLi.     .,;,:::,ijLGGGDDDDDDDDDDDD *
 *tt;.      ....:::::.                ...,.            iDEEEEKKKKKKKKWKKWKWWWWWKKWWWKKKKKKKKtWKt#WWWKKEEEEEDji..DDKDDEDEGiWKEEEEEEEEEEDDEjEEEEEEEEEEEDEEEEEEEKWKEEDDDDGGff.      .:,;,,;ijLGGGDDDDDDDDDDDD *
 *tt;.        ....::::..              .:.,:           .LDEEEKKKKKKKKKKKKWWWWKWWWWWWWWWWKKKKWtKKiDWWWKKKEEEEKi:..DEDDDDDDiiWKEEEEEEEEEEDDEijDEEEEEKEEEEEEEEEEEEWWEEGDDDGGLG.       .:,;;iijLGGGDDDDDDDDDDDD *
 *tt;.          .....:::..            ...,.           .fEEEEKKKKKKKKWKKKKWWWWWWWWWWWWWWKWKKKiKDiLWWWWKEEEEEi,..fD:DDDDDti;WEEEEEEEEEEKDDi:iDDEEEEWEEEEEEEEEEEE#WEEGDDDDGGG.         :,iitjLGGGDDDDDDDDDDDD *
 *tti.            .....:::..          ...,.           GDEEEKKKKKKKKKWKKKWWW#WWWWWWWWWWWKWKKjiEjitWWWKKWEEEDi...DDLDDDDji;;WEEEEEEEEEEEDEj.iDDEEEEWEEEEEEEEEEEEWWEEDDDDDDGf.          .,;tjfLGGDDDDDDDDDDDD *
 *tti.              ....::::..        ...,.           fEEEKKKKKKKKKKKKKKKW#WWWWWWWWWWWWWWWWtiEiiiWWWKKEWKEi....D.EDDDEi;.fWEEEEEEEEEEDDfL.;EDDEEEWEEEEEEEEEEEEWWEEEDDDDDGf.           :;ijfLGGDDDDDDDDDDDD *
 *tti.                ....::::..      ...,.          LDEEEKKKKKKKKKKKKKKWWWWWWWWWWWWWWWW####WKiiiWWWKKKEEK,...:E:DDDEii..GWEEEEEEEEDWDDiL.,KDDEEEWEEEEEEEEEEEEWWKEEDDDDDGf:           .,itfLGGDDDDDDDDDDDD *
 *tti.                 .....:::..     ...,.          fDEEEKKKKKKKKKWKKKKWWWWWWWWWWWWW########WLiiWWWKKKEEjD...G,DDDDi;...EWEEEEEEEEDKDEii..LDDEEEWEEEEEEEEEEEEWWWEEDDDDDGfi           .,;tfLGGGDDDDDDDDDDD *
 *tti.                   .....:::..   ...,.         iGEEEKKKKKKKKKKWKKKKWWWWWWWWWWWW###########KiWWWKKEEE,.D..D.DDDii:...KKEEEEEEEEEDDj:...tEDEEEWEEEEEEEEEEEEWWWEEEDDDDDLL           .,;tjLLGGDDDDDDDDDDD *
 *tti.                     ....::::......:.         LEEEKKKKKKKKKKWWKKKWWW#KWWWWWWWW#####W####W##KWWKKEEL..:D.jjDDi;,....KKEEEEEEEDfDDi...:iKDEEEWKEEEEEEEEEEEWWWEEEEDDDDLG           .,;tjLLGGDDDDDDDDDDD *
 *tti.                        ...::::::..,.        :GEEEKKKKKKKKKKKKWWWWW##WWWWWWWWW##WKWK#W#W####WWKEEK.....G.DDti,.....KKEEEEEEDWGDf.,...iKDEEEWWEEEEEEEEEEEW#WEEEEEDDDGL           .,;tjLLGGDDDDDDDDDDD *
 *tti.                         ....::::::,.        GDEEKKKKKKKKKKKKKWWWW###WWWWWWWWWW#WWWK###W#####WKEKK.....jDDL;;......KKEEEEEEEEEDi.f...;KDEEEWWEEEEEEEEEEEWWWWEEEEEDDGf           .,;tjLLGGDDDDDDDDDDD *
 *tti.                           ....:::,,.       .LEEEKKKKKWKKKKKWWWWWW###WWWWWWWWWW#WWKW#WW##W#WWWKEKD:....:DD:;......;KEEEEEEEKiDD..f...,KKEEEWWEEEEEEEEEEEWWWWEEEEEDDDf           .:;tjLLGGGDDDDDDDDDD *
 *tti.                             ...::,,,:.     GDEEKKKKKKKKKKKKWWWWWWW#WWWWWWWWWWW#KjKWWWWWWWWWWWWEK.j,..;fD.;.......fKEEEEEDKG:Di..,....DKEEEWWEEEEEEKEKKKWWWWEEEEEEDDf           .:;tjLLGGDDDDDDDDDDD *
 *jti.                              ...::,,,,:.  .fEEEKKKKKWKKKKKKWWWWWWW#WWWWWWWWWWK#KKKWWWWWWWWWWWWWK..f:.:G.,:.......EKEEEEEKK;:E:.......fKEEEWWKEKEKKKKKKKW#WWEEEEEEDDf:          .,;tfLLGGDDDDDDDDDDD *
 *tti.                               ...:,,,;;,: iDEEKKKKKWKKKKKKKWWWWWWW#WWWWWWWWWWK#WDKWWKKWWWWWWWWWE..;G:G..,........KKEEEEEKi.Gi..:.....tKEEKWWWKKKKKKKKKKW##WKEEEEEEDfi          .,;tfLLGGGDDDDDDDDDD *
 *tti.                               ....::,,;;;,LEEKKKKKKWKKKKKWWWWWWW###WWWWWWWWWWKWWDKWEEEWKKWWWWWKKj.:LG..;.........EKEEEEKG;.G...;.....;KKEKWWWKKKKKKKKKKW##WWKEEEEEDfL          .,;tfLGGGDDDDDDDDDDD *
 *jti.                                ...::::,;ijDEEKKKKKWKKKKKKWKWWWWW##WWWWWWWWWWWKK#KKGDGDWEEWKKWKKGE,.i;.:.........:EKEEEKE;.:L...j.....,KWEKWWWKKKKKKKKKK####WKKEEEEDLG          .,;tfLGGGGDDDDDDDDDD *
 *jti.                                ...:...,,;GEEKKKKKWWKKKKKWWWWWWWW###WWWWWWWWWKKKWWKiLGGEDEDEKGKKiEG..;...........jKEEEKK;:.G....,.....:KKEWWWWKKKKKKKWKK####WKKKKEEEGL          .,;tfLGGGGDDDDDDDDDD *
 *jti.                                ...:.  .:,GEEKKKKKWKKKKKWWWWWWWW####WWWWWWWWWKKKWWKii;fDLGDK: EEi:E:.............EKEEKK;;..L...........KKKWWWWKKKKKKKWKK####WKKKWKEEDf          .,;tfGGGGDDDDDDDDDDD *
 *jti.                                ...:.    ,EEKKKKKWWKKKKKWWWWWWWWW###WWWWWWWWKKKKfWWLt;i,. fi  EG..D:.............EKEKK;;..t....:.......KWKWWWWKKKKKKKWKK####WKKKWEEEDf:.        .,;tfGGGGDDDDDDDDDDD *
 *jti.                                ...:.    GEEKKKKKWKKKKKWWWWWWWWW####WWWWWWWKKKKKt;KKEfff     .;t.................KKKKi;:..GtGGfG.......KWWWWWWKKKKKKKWKK###WWWKKKKEEEf,,:       .,;tfGGGGDDDDDDDDDDD *
 *jti.                                ...:.    GEKKKKKWWKKKKKWWWWWWWWWW##WWWWWWWKKKKKKt;EiKKKK,   ...t................jEKKG;;..,.....,LGi....KWWWWWWKKKKKKWKKKW####WKKKKKEEL,,,:.     .,;tfGGGDDDDDDDDDDDD *
 *jti.                                ...:.  .GEEKKKKKWKKKKKWWWWWWWWWW###WWWWWWWKKKKKKtiE::tGG........................EEEj;;...,.........:D..DKWWWWWWKKKKK#KKW###W#WKKKKKEEfj:,,,:.   .,;tfGGGDDDDDDDDDDDD *
 *jti.                                ...:.   DEKKKKKWWKKKKKWWWWWWWWW####WWWWWWWKKKKKKiiE:::.::.......................EEi;;...j.....f......:iDKWWWWWWKKKKK#WW######WKKKKKEELG :,,,,:. .,;tfGGGDDDDDDDDDDDD *
 *jti.                                ...:.  fEEKKKKWWKKKKWWWWWWWWWWW###WWWWWWWWKKKKKK;tE::..........................DD;.;,.::......;........EWWWWWWWKKKKW#WW#####WWKKKWKKELG  .:,,,:::,;tfGGGDDDDDDDDDDDD *
 *jti.                                ...:. .DEKEKKKWWKKKKWWWWWWWWWWW###WWWWWWWWKKKKKE,iD::..........................D..,;.,;tLffi...........DWDWWWW#KKKWWWWW#####W#KKKWKEEGL    .:,;,,,;tfGGGDDDDDDDDDDDD *
 *jti.                                ...:. ;EEKKKKWWKKKKKWWWWWW#WWWW####WWWWWWKKKKKEL:iD:..........................j ..;..;;:.....i,........DKtWWWWWKKWWWWWW#####WWWKKKEKEDf     .:,;;;itfGGGDDDDDDDDDDDD *
 *jti.                                ...:. DEKKKKKWWKKKKWWWWWWW#WWWW####WWWWWWKKKKKEj:iG...............................:....................GKiWWWWWKKWW#WWW######WWKKKKKEEf       .,;iitfGGGDDDDDDDDDDDD *
 *jti.                                ...:.:EKKKKKWWKKKKKWWWWWWW#WWW#####WWWWWKWKKKKEi:if:.................................iEKEKKKKKKDj......DKiWWWWWKWK##WW#######WWKKK:KEEL        .:;itfGGGDDDDDDDDDDDD *
 *jji.                                ...:,DEEKKKWWWKWKKWWWWWWWWWWWW#####WWWWWWWKKKKEi:it..................................j.  KKKKKKKKKKKf..DKiWWWWWKWW##WW#######WWKKK,KEEf         .,;tfGGGDDDDDDDDDDDD *
 *jji.                                ..L:iDEEKKKWWKKKKKWWWWWWWWWWWW#####WWWWWKWKKKKKi.i;..................................  . KKKWWWWWWWWK..DGiWWWWWKK##WWW#####W#WWKKKjEKEL,        .:;tfGGGDDDDDDDDDDDD *
 *jji.                               .f:::EEEKKKWWWKKKKKWWWWWWWWWWWW#####WWWWWKWKKKKK;.i,.................................::  KKEKWWWWWWfWK..EiiWWWWWKWW#WW##########KKKD,KELj        .:;tfGGDDDDDDDDDDDDD *
 *jji.                             .t::::,DEEKKKWWKKKKWWWWWWWWW#WWWW#####WWWWKKWKKKEK;.i:.................................GDDEEEKKKWWWWWtWWD.E;iWWWWWW###WW#########WWKKK.EEDG        .:;tfGGGDDDDDDDDDDDD *
 *jji.                          . j..::::EKEKKKWWWKKKKWWWWWWWWW#WWW######WWWWKKWKKKEK;.t:.................................ELLEDDEEEWWWWEtWK,.KiiWWWWWW###W##########WWKKK:EEEG     .;tjfLLGDDDDDDDDDDDDDDD *
 *jji.                          i.::::::,EEEKKWWWKKKKKWWWWWWWWW#WWW#####WWWWWKWKKKKEE,.t..................................DfiEGDDDEEKKKttKWG.KiiWWWWW##WWW##########WWKKK:fEEL  ,fGGGDDDDDDDDEEEDDDDDDDDDD *
 *jji.                        .;:..:::::DEEEKKWWWKKKKKWWWWWWWWW#WWWW####WWWWWWWKKKKED,.t..................................ifjDDGGEGDKK.ttKKE.DiWWWWW###WW##########WWWKKK:.KELiLGGGGDDDDDDDDDDDDEEEDDDDDDD *
 *jji.                       i.:.::::::,KEEKKWWWKKKKKKWWWWWWWWW#WWWW####WWWWWWWKKKKEL:.j..................................GGf,;ifLLED .iiKKi:fWWWWWW##W#W##########WWWKKK:.KKLGGDDDDDDDDDDDDDDDDEDDEEDDDDD *
 *jji.                     .j:.::::::::EEEKKKWWWKKKKKKWWWWWWWW##WWW#####WWWWWWWKKKKKf:.f..................................:EEfftf .,. ;iE,..jWWWWWWW###W############WWKKK,:KKGDDDDDDDDDDDDDDDDDDDDDDDEDDDD *
 *jji.                    .:.::::::::,,EEEKKWWWKKKKKKKWWWWWWWW##WWW#####WWWWWWWKKKKKt..G....................................EEELL;   .j....tKWWWWWWW################WWWKKtfGKGEDDDDDDDDDDDDDDDDDDDDDDDEEDD *
 *jji.                   :...:::::::,,jEEKKWWWWKKKKKKWWWWWWWWW##KWW#####KWWWWWWKKKKEi..D....................................:jEEE.........;KKWWWWWWWW#WW##W##########WWKKDLGKEKDDDDDDDDDDDDDDDDDDDDDDDDDED *
 *jji.                  i:.::::::::,,,EEEKKWWWWKKKKKWWWWWWWWWW##WWW#####WWWWWWWKKKKKi..D......................................:::::......,KKKWWWWWWWWW#####W########WWWKKKGGKKEGGGGGGGGDDDDDDDDDDDDDDDDDDE *
 *jji.                 i..:::::::::,,tEEKKWWWWKKKKKWWWWWWWWWWW##WW######WWWWWWWKKKKKi..D......................................::::......:EKKKWWWWWWWWWWW##WW########W#WKKWGGKKGGGGGGGGGGGGGGGDDDDDDDDDDDDD *
 *jji.                .:::::::::::,,,EEEKKWWWWKKKKKWWWWWWWWWWW##WW#####WWWWWWWWKKKKKi..D....................................:::::::::..tELii;KWWWWWWWWWW##WW######WWWWWWKWGGGKGGGGGGGGGGGGGGGGGGGGGGGGGGDG *
 *jjt.                :.::::::::,,,,fEEKKWWWWKKKKKKWWWWWWWWWW###WW####WWWWWWW#WKKKKKi..D....................................:::::::.:.,;;;;;;,KKWWWWWWWWW#WW########WWWKKWGGGKGGGGGGGGGGGGGGGGGGGGGGGGGGGG *
 *jji.               ;.::::::::,,,,;EEEKWWWWWKKKKKWWWWWWWWWWWW##WW###WKWWWWWK#WKKKKKi..G......................................:::::::,;;;;:...KKKWWWWWWWWWKWW#######WWWWKKGLGKDGGGGGGLLGGGGGGGGGGGGGGGGGGG *
 *jjt.              f.:::::::::,,,,fEEKKWWWWWKKKKKWWWWWWWWWWW###WW##WKKWWWWWW#WKKKKK;.jt........i.............................:::::::;j;;....:E.KKKWWWWWWWKWW#####W#WWWWKKLLGWEEGGGGGLGGGGGGGGGGGGGGGGGGGG *
 *jjt.             ...:::::::,,,,,;DEEKWWWWWKKKKKWWWWWWWWWWWW####WWWKKKWWWWWWWWKKKKK;.E;.........t.............................:::::ii;;.....D...KKWWWWWWWKWW#####WWEWWWKKGGGEKKGGGGGLGGGGGGGGGGGGGLGGGGGG *
 *fji.             ;.:::::::,,,,,;LEEKKWWWWWKKKKKWWWWWWWWWWWW####KWKKKKWWWWWWWWKKKKKi.D;..........j.............................:::tt;,.....:.....KKWWWWWWKWWWW##WWWGWWWKKGGGGKEGGGGGGGGGGGGGGGGGGGLLGGGGL *
 *fji.            t::::::::,,,,,,;EEEKWWWWWKKKKKKKWWWWWWWWWWW##WKWKKKKKWWWWWWWWKKKKKi:D;............j...........................::LL;,.............KKWWWWWKWWWWWWWWWGWWWKKGGGGKGGGGGGGGGGGGGGGGGGGGLLGGGGL *
 *fjt:            .:::::::,,,,,,,DEEKWWWWWWKKKKKKKWWWWWWWWWWWWKKWKKKKKKWWWWK#WWKKKKWitE;........... ............................:G;;:...............KKKWWKKWWWWWWWWWGWWWKKGGGGWGGGGGGGGGGGGGGGGGGGGGGGGGGL *
 *fjji;:.       .f:::::::,,,,,,,;EEEKWWWWWWKKKKKKWWWWWWWWWWWKKKKKKKKKKKWWKWWWWWKKKKWGKD;........................................L;;..................DKKWKKWWWWWWWWWGWWWKKDGGGKDGGGGGGGGGGGGGGGGGGGGGGGGGG *
 *fjjtii;,:.     :::::::,,,,,,,;EEEKWWWWWWKKKKKKWWWWWWWWWWKKKKKKKKKKKKWWWWWW#WWKKKKWiEj;......................................:i,;....,...............;KKEKWWWWWWWWWGKWWKKDDGGDEGGGDGGGGGDGGGGGGGGGGGGGGGG *
 *fjtiiiii;;:.  j::::::,,,,,,,;;EEEKWWWWW#KKKKKWWWWWWWWWKKKKKKWKKKKKKKWWWWWWWWWKKKKWtEL;:....................................;;;:...,;j................:KEEWWWWWWWWWDDWWKKDDDDDKDDDDDDDDDDDDDDDGGGGGGGGGGG *
 *fjti;;iiii;;,:::::::,,,,,,,,;EEEKWWWWWWWKKKKWWWWWWWWKKKKKKKWKKKKKKKWWWWWWW#W#KKKKWEEii;...................................f;:....,;L...................EEKWWWWWWWWDDWWKKDDDDDKEDDDDDDDDDDDDDDDDDDDDDGGGG *
 *fjt,,,;;;;ii;f::::::,,,,,,,;;EEKWWWWWWWKKKKKWWWKWWKKKKKKKKKKKKKKKKKWWWWWWW#W#KKKKWKEij;:...............................:G;,.....,;f....................:tKKWWWWWWWDDWWKKDDDDDKKDDDDDDDDDDDDDDDDDDDDDDDDD *
 *jjt. ..:,;;;;,::::,,,,,,,,;;GEEWWWWWWWWKKKKWKKWKKKKKKKKKKKKKKKKKKKKWWWWWWW#W#KKKKWEDi;j;............................,Li;L;;;..,;;f........................KKKKWWWKDDWWKKDDDGDKKGGGGGGGGDGDDDDDDDDDDDDDDD *
 *fjt.    .:,,,:::::,,,,,,,;;;EEKWWWWWWWKKKKKKWKKKKKKKKKKKKKKKKKKKKKWKKKWKW##W#KKKKWEti;;G;........................tEEEL;;;;;;;;;;L..........................DKKKKKEDDWWKEDGftiLE;;;;itjLGGGGGGDDDDDDDDDDD *
 *fjt.       .j::::,,,,,,,;;;DEEWWWWWWWWKKKKWKKKKKKKKKKKKKKKKKKKKKKKWKKWWWK##W#KKKKKEii;;;L;...................iDEEEEEEKKi;j;;;;jD.....:......................,KKKKDGGEKKE:::::;E::::::::::,tLGGDDDDDDDDDD *
 *fjt.       .;:::,,,,,,,;;;;EEKWWWWWWWWKWKKKKKKKKKKKKKKKWKKKKKKKKKKWKKWWWW#WW#KKKKKKii;;;;f;.............:tDEEEEEKKKKKKKKEti;;;L...............................EEKf;:iKKE::::::E::::::::::::::ifDDDDDDDDD *
 *fjt:        :::,,,,,,,,;;;DEEWWWWWWWWWEKKKKKKKKKKKKKKKKKKKKKKKKKKWWKKWWWW####KKKKKEiii;;;;f,.........iDEEEEKKKKKKKKKKKKKKKf;iG......i..........................fK::::KKE::::::E::::::::::::::::,tGGDDDDD *
 *fjt:       t:::,,,,,,;;;;iDEKWWWWWWKEKKKKKKKKKKKKKKKKKKKKKKKKKKKKWWKKWWWW####WKKKKLiii;;;;;L,....,Li;EDEEEEKKKKKKKKKKKKKKKKiG......;:...........................:i:::KKE:::::,E,::::::::::::::::::iGDDDD *
 *jjt.       f::,,,,,,,;;;;GEEWWWWKEEKEKKKKKKKKKKKKKKKKWKKKKKKKKKKKWWKWWWWW###WWKKKKiii;;;;;;;G,;L;;iiEEEEEEEKKKKKKKKKKKKKWWKE......;t.........:....................j::KEE:,::,,D,,::::,,,,,,:::::::::tDDD *
 *fjt:.      ,::,,,,,,,;;;;EEWWKEEEEEEKKKKKKKKKKKKKKKKWKKKKKKKKKKKWWKKWWWWW#W#KKKKKKiiiiii;;;;;i;;iiiEEKEEKKWKKKKKKKWKKKKKWWWGi;...;t......,;;;;,....................:,EEE,,,,,,D,,,,,,,,,,,,,,,,::,::::tG *
 *fjt:.     ,::,,,,,,,;;;;DEKEEEEEEEEKKKKKKKKKKKKKKKKKKKKKKKKKKKKKWWWWWWWWW#W#KKKKKKiiiii;;i;;;;;iiiKKKEKKKKWWKWWWWWWKKKKWWWWW;;;:;L.....;;;;;;;;;....................,KEE,,,,,,E,,,,,,,,,,,,,,,,,,,,,,,,; *
 *fjt:.     f:,,,,,,,;;;;jEDEEEEEEEEEKKKKKKKKKKKKKKKKKKKKKKKKKKKKKWWWWWWWW#W##KKKKKKiiiiiiii;i;;iiiEKKKKKKKKWKWWWWWWWWKKKWWWWWKi;;i.....,jEEfGi;;;;;...................EED,,,,,,E,,,,,,,,,,,,,,,,,,,,,,,,, *
 *fjt:.    .f::,,,,,,;;jEEDEEEEEEEEEEKKKKKKKKKKKKKKKWKKKKKKKKKKKKKWWWKWWWWW###KKKKKLiiiiiiiiiiiiiiEEKKKKKKKKWWWWWWWWWWWWKWWWWWWGi;i;,..;jDDDKEGi;;;;;;:................EED,,,,,,D,,,,,,,,,,,,,,,,,,,,,,,,, *
 *fjt:.  .. ;::,,,,,;;EDDEEEEEEEEEEKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKWWKKW#WW####KWKKKiiiiiiiiiiiiijKKKKKKKKKKWWWWWWWWWWWWWWWWWWWWWt;i;;;;i;DDDDDDGi;;;;;;;;:.............EDf;,,,;,G;;;;;;;;;;;;;;;,,,,,,,,,, *
 *fjt:......:,,,,,,;LDDDEEEEEEEEEEEKKKKKKKKKKKKKKKKWKKKKKKKKKKKKKWWWWKWWWW####KKKKKiiiiiiiiiiijKEKKWKKKKKKKWWWWWWWWWWWWWWWWWWWWWWiLiii;i;DEEEEDDE;i;;;;;;;;;:..........EDi,;;;;;L;;;;;;;;;;;;;;;;;;,,,,,,, *
 *fjt:......:,,,,,;EDDDEEKEEEEEEEEEKKKKKKKKKKKKKKKWKKKKKKKKKKKKKKWWWWKKWWW##W#KWKKWEiiiiiijGKKKKKWWKKKKKKKKWWWWWWWWWWWWWWWWWWWWWWKi;iiiiDDEEEEEEDEi;;;;;;;;;;;;;,:.....ED;;;;;;;j;;;;;;;;;;;;;;;;;;;;;;;,, *
 *fjt:.....t,,,,,;DDDDEEEKEEEEEEEEKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKWWWKKKWWWW##WKWKKWKiiiKKKKKKKKKWWKKKKKKKKWWWWWWWWWWWWWWW#WWWWWWWWWiiiiifLEEEEEEEEDi;i;;;;;;;;;;;;.....DD;;;;;;;i;;;;;;;;;;;;;;;;;;;;;;;;; *
 *fjt:.....G,,,,,GDDDEEEEEEEEEEEEKKKKKKKKKKKKKKKKWKKKKKKKKKKKKKKKWWWKKKWWW###WKWKKWKitKKKKKKKKKWKKKKKKKKKKWWWWWWWWWWWWWW###WWWWWWWWEiiiiiiiEEEEEEEEDGiiii;;;;;;;;;.....GD;;;;;;;i;;;;;;;;;;;;;;;;;;;;;;;;; *
 *fjt:.....L,,,,;GDDDEEEEEEEEEEKEKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKWWWWWDGWWW###KKWWKWKKKKKKKKKKKKKKKKKKKKKKKWWWWWWWWWWWWW####WWWWWWWWWiiiiiiiiEEEEEEEEEEDi;i;;;;;;;;.....Lj;;;;;;i;iiiiii;;;;;;ii;;;;;;;;;;; *
 ***********************************************************************************************************************************************************************************************************/

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef pair<ll,ll> lll;
typedef pair<ll,int> lli;
typedef pair<int,int> ii;

#define pb push_back
#define mp make_pair
#define ep emplace_back
#define X  first
#define Y  second
#define fillchar(a,x) memset(a, x, sizeof(a))
#define FOR(i,l,r) for (int i=l;i<=r;i++)
#define FORD(i,r,l) for (int i=r;i>=l;i--)

const int base = 1e9;
typedef vector<int> BigInt;

void Set(BigInt &a) {
    while (a.size() > 1 && a.back() == 0) a.pop_back();
}

void Print(BigInt a) {
    Set(a);
    printf("%d", (a.size() == 0) ? 0 : a.back());
    FORD(i,a.size()-2,0) printf("%09d", a[i]);
}

BigInt Integer(string s) {
    BigInt ans;
    if (s[0] == '-') return ans;
    if (s.size() == 0) {ans.pb(0); return ans;}
    while (s.size()%9 != 0) s = '0'+s;
    for (unsigned int i=0;i<s.size();i+=9) {
        int v = 0;
        for (unsigned int j=i;j<i+9;j++) v = v*10+(s[j]-'0');
        ans.insert(ans.begin(),v);
    }
    Set(ans);
    return ans;
}

BigInt Integer(ll x) {
    string s = "";
    while (x > 0) s = char(x%10+'0') + s, x /= 10;
    return Integer(s);
}

BigInt Integer(int x) {
    return Integer((ll) x);
}

istream& operator >> (istream &in, BigInt &a) {
    string s;
    in >> s;
    a = Integer(s);
    return in;
}

ostream& operator << (ostream &out, BigInt a) {
    Print(a);
    return out;
}

bool operator < (BigInt a, BigInt b) {
    Set(a);
    Set(b);
    if (a.size() != b.size()) return (a.size() < b.size());
    FORD(i,a.size()-1,0)
        if (a[i] != b[i]) return (a[i] < b[i]);
    return false;
}

bool operator > (BigInt a, BigInt b) {
    return (b < a);
}

bool operator == (BigInt a, BigInt b) {
    return (!(a < b) && !(b < a));
}

bool operator <= (BigInt a, BigInt b) {
    return (a < b || a == b);
}

bool operator >= (BigInt a, BigInt b) {
    return (b < a || b == a);
}

bool operator < (BigInt a, int b) {
    return (a < Integer(b));
}

bool operator > (BigInt a, int b) {
    return (a > Integer(b));
}

bool operator == (BigInt a, int b) {
    return (a == Integer(b));
}

bool operator >= (BigInt a, int b) {
    return (a >= Integer(b));
}

bool operator <= (BigInt a, int b) {
    return (a <= Integer(b));
}

BigInt max(BigInt a, BigInt b) {
    if (a > b) return a;
    return b;
}

BigInt min(BigInt a, BigInt b) {
    if (a < b) return a;
    return b;
}

BigInt operator + (BigInt a, BigInt b) {
    Set(a);
    Set(b);
    BigInt ans;
    int carry = 0;
    for(unsigned int i = 0; i < max(a.size(), b.size()); i++) {
        if (i < a.size()) carry += a[i];
        if (i < b.size()) carry += b[i];
        ans.pb(carry%base);
        carry /= base;
    }
    if (carry) ans.pb(carry);
    Set(ans);
    return ans;
}

BigInt operator + (BigInt a, int b) {
    return a + Integer(b);
}

BigInt operator ++ (BigInt &a) { // ++a
    a = a + 1;
    return a;
}

void operator += (BigInt &a, BigInt b) {
    a = a + b;
}

void operator += (BigInt &a, int b) {
    a = a + b;
}

BigInt operator - (BigInt a, BigInt b) {
    Set(a);
    Set(b);
    BigInt ans;
    int carry = 0;
    for(unsigned int i = 0; i < a.size(); i++) {
        carry += a[i] - (i < b.size() ? b[i] : 0);
        if (carry < 0) ans.pb(carry+base), carry = -1;
        else ans.pb(carry), carry = 0;
    }
    Set(ans);
    return ans;
}

BigInt operator - (BigInt a, int b) {
    return a - Integer(b);
}

void operator -- (BigInt &a) { // --a
    a = a - 1;
}

void operator -= (BigInt &a, BigInt b) {
    a = a + b;
}

void operator -= (BigInt &a, int b) {
    a = a - b;
}

BigInt operator * (BigInt a, BigInt b) {
    Set(a);
    Set(b);
    BigInt ans;
    ans.assign(a.size()+b.size(), 0);
    for(unsigned int i = 0; i < a.size(); i++) {
        ll carry = 0ll;
        for (unsigned int j=0;j<b.size() || carry > 0;j++) {
            ll s = ans[i+j] + carry + (ll)a[i]*(j<b.size()?(ll)b[j]:0ll);
            ans[i+j] = s%base;
            carry = s/base;
        }
    }
    Set(ans);
    return ans;
}

BigInt operator * (BigInt a, int b) {
    return a * Integer(b);
}

void operator *= (BigInt &a, BigInt b) {
    a = a * b;
}

void operator *= (BigInt &a, int b) {
    a = a * b;
}

BigInt operator / (BigInt a, BigInt b) {
    Set(a);
    Set(b);
    if (b == Integer(0)) return Integer("-1");
    BigInt ans, cur;
    FORD(i,a.size()-1,0) {
        cur.insert(cur.begin(), a[i]);
        int x = 0, L = 0, R = base;
        while (L <= R) {
            int mid = (L+R)>>1;
            if (b*Integer(mid) > cur) {
                x = mid;
                R = mid-1;
            }
            else
                L = mid+1;
        }
        cur = cur - Integer(x-1)*b;
        ans.insert(ans.begin(),x-1);
    }
    Set(ans);
    return ans;
}

BigInt operator / (BigInt a, int b) {
    Set(a);
    BigInt ans;
    ll cur = 0ll;
    FORD(i,a.size()-1,0) {
        cur = (cur*(ll)base + (ll)a[i]);
        ans.insert(ans.begin(),cur/b);
        cur %= b;
    }
    Set(ans);
    return ans;
}

void operator /= (BigInt &a, BigInt b) {
    a = a / b;
}

void operator /= (BigInt &a, int b) {
    a = a / b;
}

BigInt operator % (BigInt a, BigInt b) {
    Set(a);
    Set(b);
    if (b == Integer(0)) return Integer("-1");
    BigInt ans;
    FORD(i,a.size()-1,0) {
        ans.insert(ans.begin(), a[i]);
        int x = 0, L = 0, R = base;
        while (L <= R) {
            int mid = (L+R)>>1;
            if (b*Integer(mid) > ans) {
                x = mid;
                R = mid-1;
            }
            else
                L = mid+1;
        }
        ans = ans - Integer(x-1)*b;
    }
    Set(ans);
    return ans;
}

int operator % (BigInt a, int b) {
    Set(a);
    if (b == 0) return -1;
    int ans = 0;
    FORD(i,a.size()-1,0)
        ans = (ans*(base%b) + a[i]%b)%b;
    return ans;
}

void operator %= (BigInt &a, BigInt b) {
    a = a % b;
}

void operator %= (BigInt &a, int b) {
    a = a % Integer(b);
}

BigInt gcd(BigInt a, BigInt b) {
    Set(a);
    Set(b);
    while (b > Integer(0)) {
        BigInt r = a%b;
        a = b;
        b = r;
    }
    Set(a);
    return a;
}

BigInt lcm(BigInt a, BigInt b) {
    return (a*b/gcd(a,b));
}

BigInt sqrt(BigInt a) {
    BigInt x0 = a, x1 = (a+1)/2;
    while (x1 < x0) {
        x0 = x1;
        x1 = (x1+a/x1)/2;
    }
    return x0;
}

BigInt pow(BigInt a, BigInt b) {
    if (b == Integer(0)) return Integer(1);
    BigInt tmp = pow(a, b/2);
    if (b%2 == 0) return tmp * tmp;
    return tmp * tmp * a;
}

BigInt pow(BigInt a, int b) {
    return pow(a,(Integer(b)));
}

int log(int n, BigInt a) { // log_n(a)
    Set(a);
    int ans = 0;
    while (a > Integer(1)) {
        ans++;
        a /= n;
    }
    return ans;
}

int main()
{
    // BigInt B;  cin >> B;
    // BigInt A = Integer("123456789");
    // BigInt C = Integer(123456789ll);
    // int x; x = 123456789;
    //
    // if (B <= A) cout << A - B;
    // else {
    //     cout << "-";
    //     cout << B - A;
    // }
    //
    // cout << A + B; Print(A + x);
    // cout << A * B; Print(A * x);
    // cout << A / B; Print(A / x);
    // cout << A % B; printf("%d\n", A % x);
    //
    // C = ++A; ++B; C += B + x;
    // Print(A); Print(B); Print(C);
    //
    // cout << max(A,B);
    // cout << min(A,B);
    //
    // cout << gcd(A,B);
    // cout << lcm(A,B);
    //
    // cout << sqrt(A);
    // printf("%d %d %d\n", log(2,A), log(10,B), log(5,C));
    //
    // A = Integer(16); x = 12;
    // cout << pow(A,B);
    // cout << pow(A,x);

    //long long lt, la, lb;
    BigInt t, a, b, lcms, _lcm, e, d;
    cin >> t >> a >> b;

    if(a>b) swap(a,b);
    _lcm = lcm(a,b);
    lcms = t / _lcm;
    e = min(a - 1, t);
    if(lcms > 0){
      e += (lcms - 1) * a;
      e += min( t - (lcms * _lcm) + 1, a);
    }

    if(e > 0){
      d = gcd(e,t);
      e /= d;
      t /= d;
    } else
      t = Integer(1);

    cout << e << "/" << t << endl;

    return 0;
}

#include <iostream>
#include <stdio.h>
#include <cstring>
#include <algorithm>
#include <cmath>
#define ll long long
using namespace std;
ll len,a,b;
ll gcd(ll a,ll b){
    if(b==0)return a;
    return gcd(b,a%b);
}
inline ll lcm(ll a,ll b){
    return a/gcd(a,b)*b;
}
int main()
{
    scanf("%I64d",&len);

    scanf("%I64d%I64d",&a,&b);
    if(a>b) swap(a,b);
    ll d=lcm(a,b);
   if(a==b){
        printf("1/1");
        return 0;
    }else if(d>len||a>=len){
        if(a>len)
            printf("1/1\n");
        else {
            int q=gcd(a-1,len);
            printf("%I64d/%I64d",(a-1)/q,len/q);

        }
        return 0;
    }
 double x=((double)d)/a,y=((double)d)/b;
    if(d<0||d>len||d<b||x-(int)x>1e-7&&y-(int)y>1e-7){

        ll t=gcd(a-1,len);
        printf("%I64d/%I64d\n",(a-1)/t,len/t);
    }

else{
   ll k=len/d;
    ll u=len-k*d;

    ll ans=a*k;

    if(u<a&&u) ans+=(u+1);
    else if(u&&u>=a)ans+=a;
else if(!u)ans++;
ans--;
    ll p=0;p=gcd(ans,len);

    printf("%I64d/%I64d\n",ans/p,len/p);
}
    return 0;
}

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
const ll N = 1e10;

ll gcd(ll a,ll b){
    return b==0? a : gcd(b,(a%b));
}

int main()
{
    ll t,w,b;
    ll p;
    cin >> t >> w >> b;
    if(w > b)swap(w,b);
    ll GCD = gcd(w,b);
    if(w==b || t < w)p = t;
    else if(1.0 * b / GCD * w - t > 0){p=w-1;}
    else{
         ll lcm = b / GCD * w;
         ll x = t / lcm;
         p = min(w, t - x * lcm + 1) + x * w;
         p--;
    }
    ll d = gcd(p,t);
    printf("%lld/%lld\n",p/d,t/d);
    return 0;
}

#include<iostream>
#include<algorithm>
#include<vector>
#include<cmath>
#include<map>
#include<string>

using namespace std;

long long gcd(long long a, long long b)
{
    while (a != 0)
    {
        b = b % a;
        swap(a, b);
    }
    return b;
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    unsigned long long t,a,b,c,d,k,z;
    cin >> t >> a >> b;
    if (a > b) swap(a, b);
    c = gcd(a, b);
    d = b / c;
    if (t / a < d)
    {
        k = 0;
    }
    else
    {
        z = a * d;
        k = t / z;
    }
    long long p, q=t;
    if (k == 0)
    {
        p = min(t, a-1);
    }
    else
    {
        p = a - 1;
        p += k;
        p += (k - 1)*(a - 1);
        p += min(t%z, a-1);
    }
    c = gcd(p, q);
    p = p / c;
    q = q / c;
    cout << p << "/" << q << endl;
    return 0;
}

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef  long long LL;
#define  INF 0x3f3f3f3f3f3f3f3f
LL gcd(LL a,LL b)
{
          return b==0 ? a : gcd(b,a%b);
}
int main()
{
    LL t,n,m;
    cin>>t>>n>>m;

    LL sum=0;
    LL b=min(n,m);
    LL z=gcd(n,m);
    LL a=z;
    a=n/a*m;
    LL f=INF/m;
    if(f>n/z)
    {
            sum+=t/a;
            sum+=t/a*(b-1);

            sum+=min(t%a,b-1);
    }
    else sum+=b-1;

    a=sum>t ? t: sum;

    n=gcd(a,t);
    cout <<(a/n)<<"/"<<t/n<<endl;
    return 0;
}

#include<iostream>
#include<algorithm>
using namespace std;
typedef unsigned long long ull;

ull gcd(ull l, ull r){
    if (r == 0) return l;
    else gcd(r, l%r);
}

int main(){
   // freopen("input.txt", "r", stdin);
    ull l, w, b;
    cin >> l >> w >> b;
    ull g = gcd(w, b);
    ull m = min(w, b);
    ull q = l / g;
    w = w / g;
    b = b / g;
    q = q / w;
    q = q / b;

    //
    ull min_fac = g*b * w;//최소 공배수
    ull prev = q*m - 1;
    prev = prev + min((l - min_fac*q)+1, m);
    ull rgcd = gcd(prev, l);
    prev /= rgcd;
    l /= rgcd;
    if (prev < l){
        cout << prev;
        cout << "/" << l;
    }
    else{
        cout << 1;
        cout << "/" << 1;
    }
    return 0;
}

#include <stdio.h>
#include <math.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#define MM(a) memset(a,0,sizeof(a))
typedef long long LL;
inline int cmin(int a, int b){return a>b?b:a;}
inline int cmax(int a, int b){return a>b?a:b;}
LL INF = 9223372036854775807;

LL gcd(LL a, LL b)
{
    return b==0?a:gcd(b, a%b);
}

LL lcm(LL a, LL b)
{
    return a/gcd(a,b)*b;
}
bool overload_of_lcm(LL a, LL b)
{
    double da, db, dg;
    da = a;
    db = b;
    dg = gcd(a,b);
    if (da*db/dg > INF - 1)
        return false;
    else
        return true;
}
int main()
{
    LL t, w, b, ans = 0;
    LL Tmin;

    scanf("%I64d%I64d%I64d",&t,&w,&b);
    if ((t < w && t < b) || w == b)
    {
        printf("1/1\n");
        return 0;
    }
    if (w > b) Tmin = b; else Tmin = w;

    if (!overload_of_lcm(w,b))
        ans += Tmin - 1;
    else
    {
        ans += t / lcm(w,b) * Tmin;
        if (t % lcm(w, b) >= Tmin)
            ans += Tmin-1;
        else
            ans += t % lcm(w,b);
    }
    LL g = gcd(ans,t);
    ans/=g;
    t/=g;
    printf("%I64d/%I64d\n", ans,t);
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
const int maxn=1500;
const int inf=0x3f3f3f3f;
typedef unsigned long long ull;
ull t,a,b,g;
int main()
{
    cin>>t>>a>>b;
    ull k=min(a,b);
    ull a1=a/__gcd(a,b);
    ull b1=b/__gcd(a,b);
    ull g=a1*b1*__gcd(a,b);
    ull p,q;
    ull ans=0;
    if((double)t<(double)a1*(double)b1*(double)__gcd(a,b))
    {
    ans=min(t,min(a-1,b-1));
    }
    else
    {
         ans=(t/g)*k+ min(k,t%g+1) -1;
    }
    //cout<<ans<<endl;
    ull fact=__gcd(ans,t);
    p=ans/fact;
    q=t/fact;
    cout<<p<<"/"<<q<<endl;

    return 0;
}

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

const ll INF = 6e18;

int main() {
    ll t, w, b;
    cin >> t >> w >> b;
    ll good = 0;
    if(w == b){
        cout << "1/1\n";
        return 0;
    }
    ll g = __gcd(w, b);
    if(w/g > INF/b)
        good = min(t + 1, min(w, b)) - 1;
    else {
        ll pd = w/g * b;
        ll cy = (t + 1)/pd;
        ll k = (t + 1)% pd;
        good = min(w, b) * cy + min(k, min(w, b));
        good--;
    }
    g = __gcd(good, t);
    cout << good/g << "/" << t/g << '\n';
}

#include <functional>
#include <algorithm>
#include <iostream>
#include <memory.h>
#include <sstream>
#include <assert.h>
#include <fstream>
#include <iomanip>
#include <bitset>
#include <string>
#include <cstdio>
#include <complex>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <ctime>
#include <set>
#include <map>

using namespace std;

long long t, w, b;
long long ans;

long long gcd(long long a, long long b)
{
    if (b == 0)
        return a;
    else
        return gcd(b, a % b);
}

bool f(long long a, long long b, long long c)
{
    if (a <= c / b)
        return true;
    else
        return false;
}

int main()
{
#ifdef _DEBUG
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif
    scanf("%I64d%I64d%I64d", &t, &w, &b);
    long long g = gcd(w, b);
    long long tmpw = w / g;
    if (f(tmpw, b, t) == true)
        tmpw = tmpw * b;
    else
        tmpw = 0;
    long long k = 0;
    if (tmpw != 0)
        k = t / tmpw;
    ans = k + k * (min(w, b) - 1);
    long long l = k * tmpw + 1;
    long long r = min(k * tmpw + min(w, b) - 1, t);
    ans += r - l + 1;
    g = gcd(ans, t);
    cout << ans / g << "/" << t / g << endl;

    return 0;
}

#include<stdio.h>
#include<string.h>
#include<map>
#include<set>
#include<cmath>
#include<algorithm>
#include<vector>
#include<queue>
#include<iostream>
using namespace std;
typedef __int64 ll;
typedef unsigned __int64 ULL;
#define inf 99999999
#define maxn 10
ll t,w,b;
ll gcd(ll a,ll b){
    return b==0?a:gcd(b,a%b);
}
int main(){
    scanf("%I64d%I64d%I64d",&t,&w,&b);
    ll yue=gcd(w,b);
    double bei=(double)w/yue*b;     //这里求出来的最小公倍数十分的大，所以先用double存入
    ll m=min(w,b);
    ll ans=0;
    //为什么我们其中一个要用double型呢？就是为了先判断这个bei是否会溢出，然后再进行相应的操作
    if(bei>t){
        ans=min(t,m-1);
    }
    else{
        ans=t/(ll)bei*m-1;
        ans+=min(t%(ll)bei+1,m);
    }
    //printf("%I64d\n",ans);
    ll res=gcd(ans,t);
    printf("%I64d/%I64d\n",(ans/res),(t/res));
    return 0;
}
/*
4000000000000000000 9999999999999997 99999999999999999
*/

#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define mod 1000000007
#define F first
#define S second
#define all(v) (v).begin(),(v).end()
#define np next_permutation
using namespace std;
using vi=vector<int>;
#define lp(i,n) for(int i=0;i<n;i++)
#define lps(i,j,n) for(int i=j;i<n;i++)
#define vii vector<vi>
#define vb vector<bool>
#define pr pair<int,int>
#define vl vector<ll>
#define vs vector<string>
#define us unordered_map<int,int>
#define Mpq priority_queue<int>
#define mpq priority_queue<int,vi,greater<int>>
#define eb emplace_back
#define pr pair<int,int>
#define prl pair<ll,ll>
#define vp vector<pr>
#define vpl vector<prl>
#define mkp make_pair
#define ld long double
#define vii vector<vi>
#define Max(a,b) a=max(a,b)
#define Min(a,b) a=min(a,b)
#define ull unsigned long long
const int N=1e5+11;
ll t,w,b,s,ans;
ll gcd(ll x,ll y){
   if(x%y == 0) return y;
   return gcd(y,x%y);
}
void solve(){
    cin >> t >> w >> b;
    ll g = __gcd(w,b);
    double  prdt = (double)w*b;
    ll l = (ll)(prdt/g);
    ans = min(w,b)*(t/l) - 1 + min(t%l+1, min(w,b));
    g = __gcd(ans,t);
    cout << ans/g << "/" << t/g << endl;
}
int main(){
   ios_base::sync_with_stdio(0);
   cin.tie(nullptr);

   //assert(freopen("input8.txt","r",stdin));
   //assert(freopen("output8.txt","w",stdout));

   solve();
   return 0;
}

#include <bits/stdc++.h>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
#define lli long long int
#define fop(i,m,n) for (int i=(m);i<(n);i++)
#define FOP(i,m,n) for (int i=(m)-1;i>=(n);--i)
#define test(x) cout << #x << ' ' << x << endl;
#define printv(a) {\
    for (auto i : a) cout << i << ' ';\
    cout << '\n';\
}
#define eb emplace_back
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define pii pair<int,int>
#define pdd pair<ld,ld>
typedef long double ld;
#define pll pair<lli,lli>
#define tiii tuple<int,int,int>
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define X first
#define Y second
#define oset tree<lli,null_type,less<lli>,rb_tree_tag,tree_order_statistics_node_update>
#define readfile freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
auto SEED = chrono::steady_clock::now().time_since_epoch().count();
mt19937 rng(SEED);
const int mod = 998244353, x = 864197532, N = 1001, logN = 17, K = 500;

int main () {
    ios::sync_with_stdio(false);
    cin.tie(0);
    lli q, a, b;
    cin >> q >> a >> b;
    lli g = __gcd(a, b);
    lli k = min(a, b), p;
    if (q / (a / g) / b < 1) p = min(k - 1, q);
    else {
        lli lcm = (a / g) * b;
        p = q / lcm * k + min(k, q % lcm + 1) - 1;
    }
    g = __gcd(p, q);
    cout << p / g << '/' << q / g << endl;
}

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define db long double
#define pb push_back
#define pii pair<int,int>
#define vi vector<int>
#define vl vector<ll>
#define vii vector<pii>
#define mi map<int,int>
#define ml map<ll,ll>
#define mii map<pii,int>
#define fi first
#define se second
#define all(a) (a).begin(),(a).end()
#define sz(x) (int)x.size()
#define mod 1000000007
#define MAX 4294967295
#define EPS 1e-9
#define io ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define MAXN 15000005
#define inf 8e18
#define PI acos(-1.0)
#define int long long

int t,w,b,ans;

signed main(){
    io;
    //freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
    cin>>t>>w>>b;
    if(w>b) swap(w,b);
    if(w==1) ans=t/b;
    else if(w/__gcd(w,b) > (db)(t/b)) ans=min(t,w-1);
    else{
        int lcm = (w/__gcd(w,b))*b;
        ans+=(t/lcm)*min(w,b);
        int z=t%lcm;
        if(z>=min(w,b)) ans+=min(w,b);
        else ans+=(z+1);
        ans--;
    }
    cout<<ans/__gcd(ans,t)<<"/"<<t/__gcd(ans,t);
    return 0;
}

#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <algorithm>
using namespace std;

#define nln        puts("")                         ///prLLInewline
#define getLLI(a)  scanf("%d",&a);
#define max3(a,b,c) max(a,max(b,c))                  ///3 ta theke max
#define min3(a,b,c) min(a,min(b,c))                  ///3 ta theke min

#define FOR1(i,n)  for(LLI i=1;i<=n;i++)
#define FOR0(i,n)  for(LLI i=0;i<n;i++)                 ///looping
#define FORR(i,n)  for(LLI i=n-1;i>=0;i--)
#define ALL(p)     p.begin(),p.end()

#define SET(p)     memset(p,-1,sizeof(p))
#define CLR(p)     memset(p,0,sizeof(p))            ///memset
#define MEM(p,v)   memset(p,v,sizeof(p))

#define READ(f)    freopen(f, "r", stdin)           /// file
#define WRITE(f)   freopen(f, "w", stdout)

#define SZ(c)      (LLI)c.size()
#define PB(x)      push_back(x)                     ///STL defines
#define MP(x,y)    make_pair(x,y)
#define ff         first
#define ss         second

#define LI         long LLI
#define LLI        long long
#define f64        long double
#define PI         acos(-1.0)                        ///PI er value

LLI Set(LLI N,LLI pos)
{
    return N=N | (1<<pos);
}
LLI reset(LLI N,LLI pos)
{
    return N= N & ~(1<<pos);
}
bool check(LLI N,LLI pos)
{
    return (bool)(N & (1<<pos));
}
void CI(int &_x)
{
    scanf("%d",&_x);
}

void CO(LLI &_x)
{
    cout<<_x;
}

template<typename T> void getarray(T a[],LLI n)
{
    for(LLI i=0; i<n; i++) cin>>a[i];
}
template<typename T> void prLLIarray(T a[],LLI n)
{
    for(LLI i=0; i<n-1; i++) cout<<a[i]<<" ";
    cout<<a[n-1]<<endl;
}

const double EPS=1e-9;                              ///constatnts
const LLI INF=0x7f7f7f7f;

LLI dr8[8]= {1,-1,0,0,1,-1,-1,1};            ///8 direction move
LLI dc8[8]= {0,0,-1,1,1,1,-1,-1};
LLI dr4[4]= {0,0,1,-1};                      ///4 direction move
LLI dc4[4]= {-1,1,0,0};                      ///or adjacent dir.
LLI kn8r[8]= {1,2,2,1,-1,-2,-2,-1};          ///knight moves
LLI kn8c[8]= {2,1,-1,-2,-2,-1,1,2};
LLI gcd(LLI a,LLI b)
{

    if(b==0)return a;
    return gcd(b,a%b);

}
LLI t;
LLI lcm(LLI a,LLI b)
{

    LLI g=gcd(a,b);
    a/=g;
    if(t/a<b){
           // puts("OKk");
            //while(1);

          LLI up=min((a*g)-1,t);
              LLI down=t;

          //  cout<<"FF "<<up<<" "<<down<<"\n";
            LLI u=gcd(up,down);

          up/=u,down/=u;
cout<<up<<"/"<<down<<"\n";
//exit('0');
    t=-1;
    return 0;
    }
    return a*b;
}
int main()
{
    LLI a,b;
    cin>>t>>a>>b;
    if(a>b)swap(a,b);
    LLI up=0;

    LLI LCM=lcm(a,b);
    if(t==-1)return 0;
//    cout<<"FF "<<LCM<<"\n";
    LLI div=t/LCM;

    up+=div*a;
    LLI dis=LCM*div;

    up+=min(dis+a-1,t)-dis;
    LLI g=gcd(up,t);
    up/=g,t/=g;
    cout<<up<<"/"<<t<<"\n";

}

#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define lb lower_bound
#define ull unsigned ll
#define gcd(a,b) __gcd(a,b)
#define pii pair<int,int>
#define all(x) x.begin(),x.end()
#define ll long long
#define mp make_pair
#define pi acos(-1)

#define mod 1000000007
#define inf int(1e9)

long long n,a,b;
long long mx = (1LL<<63)-1;

bool check()
{
    long long g = gcd(a,b);
    if(n<a||n<b) return 0;
    long long tmp = a / g;
    if(n/tmp<b) return 0;
    return 1;
}

int main()
{
    int i,j,k;
    //cout << mx << endl;
    while(cin>>n>>a>>b)
    {
        if(a>b) swap(a,b);
        long long ans = 0;
        long long tmp = n;
        if(check())
        {
            long long g = gcd(a,b);
            long long lcm = a/g*b;
            ans = (tmp/lcm)*a;
            tmp = tmp % lcm;
        }
        ans += min(a-1,tmp);
        long long g = gcd(ans,n);
        cout << ans/g <<'/' << n/g << endl;
    }
}

#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ull;

ull gcd(ull l, ull r){
    if (r == 0) return l;
    else gcd(r, l%r);
}

int main(){
   // freopen("input.txt", "r", stdin);
    ull l, w, b;  cin >> l >> w >> b;
    ull g = gcd(w, b);
    ull m = min(w, b);

    ull min_fac = w / g * 1. * b < 1e19 ? w / g * b : (ull)1e19;
    ull prev = l/min_fac*m - 1;
    prev = prev + min((l%min_fac)+1, m);
    ull rgcd = gcd(prev, l);
    prev /= rgcd;
    l /= rgcd;

    cout << prev << "/" << l;

    return 0;
}

/// #bettercoderthanshebeautiful
/// Now on codeforces too
/// 28h 25min
#include<bits/stdc++.h>
#define ull unsigned long long
using namespace std;
ull inf=18e18+1;
ull t,w,b;
ull lcm(ull a, ull b)
{
    ull c=0;
    ull R=a;
    ull O=b;
    while(b)
    {
        c=a%b;
        a=b;
        b=c;
    }
    if(inf/O<R/a)
        return inf;
    return R/a*O;
}
ull gcd(ull a, ull b)
{
    ull c;
    while(b)
    {
        c=a%b;
        a=b;
        b=c;
    }
    return a;
}
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    cin>>t>>w>>b;
    ull numi=t;
    ull numar=min(w,b)*(t/lcm(w,b))+min(min(w,b),t%lcm(w,b)+1)-1;
    cout<<numar/gcd(numar,numi)<<"/"<<numi/gcd(numar,numi)<<'\n';
    return 0;
}

#define push_back pb
#define make_pair mk
#include<bits/stdc++.h>
#include<iostream>
#include<stdlib.h>
#include<stdio.h>
#include<cmath>
#include<map>
#include<algorithm>
#include<string>
#include<string.h>
#include<set>
#include<queue>
#include<stack>
#include<functional>
using std::pair;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> PII;
typedef pair<PII,int> PPI;
typedef pair<ll,int> PLI;
const double PI=acos(-1);
const int maxn = 10000 + 10;
const int maxm = 100 + 10;
const int mod = 1e9+7;
const int INF = 0x3f3f3f3f;
const double dinf=1e20;
using namespace std;
int main()
{
    ll ans,n,a,b,t1,t2,t3;
    cin>>n>>a>>b;
    ll gcd=__gcd(a,b);
    ans=0;
    t1=n/a*gcd/b;
    t2=min(a,b)-1;
    ans+=t1+t1*t2;
    if(n-t1*a/gcd*b>=t2) ans+=t2;
    else
        ans+=n-t1*a/gcd*b;
    t3=__gcd(n,ans);
    cout<<ans/t3<<"/"<<n/t3<<endl;
}

/// #bettercoderthanshebeautiful
/// Now on codeforces too
/// 24h 57min
#include<bits/stdc++.h>
#define ull unsigned long long
using namespace std;
ull inf=18e18+1;
ull t,w,b;
ull lcm(ull a, ull b)
{
    ull c=0;
    ull R=a;
    ull O=b;
    while(b)
    {
        c=a%b;
        a=b;
        b=c;
    }
    if(inf/O<R/a)
        return inf;
    return R/a*O;
}
ull gcd(ull a, ull b)
{
    ull c;
    while(b)
    {
        c=a%b;
        a=b;
        b=c;
    }
    return a;
}
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    cin>>t>>w>>b;
    ull numi=t;
    ull numar=min(w,b)*(t/lcm(w,b))+min(min(w,b),t%lcm(w,b)+1)-1;
    cout<<numar/gcd(numar,numi)<<"/"<<numi/gcd(numar,numi)<<'\n';
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
#define min(x,y) ((x)<(y)?(x):(y))
#define debug puts("YES");
#define rep(x,y,z) for(int (x)=(y);(x)<(z);(x)++)
#define ll long long

#define lrt int l,int r,int rt
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define root l,r,rt
#define mst(a,b) memset((a),(b),sizeof(a))
#define pii pair<int,int>
#define fi first
#define se second
#define mk(x,y) make_pair(x,y)
int mod=20100501;
const int maxn=30+10;
const int ub=1e6;
ll powmod(ll x,ll y){ll t; for(t=1;y;y>>=1,x=x*x%mod) if(y&1) t=t*x%mod; return t;}
ll gcd(ll x,ll y){
    return y?gcd(y,x%y):x;
}
ll a,b,c;
int main(){
    scanf("%lld%lld%lld",&a,&b,&c);
    ll ans=0,GCD=gcd(b,c);
    if(1.0*b/GCD*c>(double)a){
        ans=min(a,min(b-1,c-1));
    }else{
        ll lcm=b/GCD*c;
        ll res=a-a/lcm*lcm;
        ans=a/lcm*min(b,c)+min(res,min(b-1,c-1));
    }
    ll gd=gcd(ans,a);
    printf("%lld/%lld\n",ans/gd,a/gd);
    return 0;
}

#include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
using namespace std;
// using namespace __gnu_pbds;
#define lli long long int
#define llu unsigned long long int
#define fr(va, beg, end) for (lli va = beg; va < end; va++)
#define pb push_back
#define rt return 0
#define endln "\n"
#define all(x) x.begin(), x.end()
#define sz(x) (lli)(x.size())
const lli MOD = 1e9 + 7;
// cout << fixed << setprecision(0) << pi <<endl;
// typedef tree<int, null_type, less<int>, rb_tree_tag,
//              tree_order_statistics_node_update>
//     new_data_set;
// for multiset
// typedef tree<int, null_type, less_equal<int>, rb_tree_tag,
//              tree_order_statistics_node_update>
//     new_data_set;
// order_of_key(val): returns the number of values less than val
// find_by_order(k): returns an iterator to the kth largest element (0-based)

void solve() {
    lli n, a, b;
    cin >> n >> a >> b;
    if (a == b) {
        cout << "1/1" << endl;
        return;
    }

    if (a > b) {
        swap(a, b);
    }

    lli lcm = b / (__gcd(a, b));

    if (a > (n / lcm)) {
        lli pp = a - 1;
        lli nn = min(pp, n);
        lli vv = __gcd(nn, n);
        lli p = nn / vv;
        lli q = n / vv;
        cout << p << "/" << q << endl;
    } else {
        lcm = lcm * a;

        lli ans = n / lcm;
        ans++;
        ans = ans * a;
        ans--;
        // cout << ans << endl;
        lli val = ((n / lcm) * lcm) + a - 1;
        if (val > n) {
            ans -= (val - n);
        }

        lli vv = __gcd(ans, n);
        lli p = ans / vv;
        lli q = n / vv;
        cout << p << "/" << q << endl;
    }
}

int main(void) {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    // lli t; cin >> t; while(t--)
    solve();
    rt;
}

#include <bits/stdc++.h>

using namespace std;
#define ull unsigned long long

ull t,w,b,res,uc,sl;

ull ucln(ull a, ull b)
{
    while (a%b!=0)
    {
        ull c=a%b;
        a=b;
        b=c;
    }
    return b;
}

int main()
{
    cin >> t >> w >> b;
    res+=min(min(w,b)-1,t);
    uc=ucln(w,b);
    ull k=5*1e18/w;
    if (b/uc>k) {ull ucl=ucln(res,t);res/=ucl;
    t/=ucl;cout << res << "/" << t; return 0;}
    ull tmp=w*(b/uc);
    sl=t/tmp;
    if (sl!=0)
    {
    res+=(sl-1)*(min(w,b));
    res+=min(t-sl*tmp+1,min(w,b));
    }
    ull ucl=ucln(res,t);
    res/=ucl;
    t/=ucl;
    cout << res << "/" << t;
}

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <cmath>
#include <vector>
#include <queue>
#include <climits>
#include <string>
#include <stack>
#include <set>
#include <map>
#include <unordered_map>
#include <fstream>
#include <algorithm>
#include <assert.h>
#include <string.h>
#include <sstream>
#include <iomanip>
#include <sstream>
#include <list>

typedef long long ll;
typedef unsigned long long ull;

#define x first
#define y second

const ll mod = 1000000007;
const int maxN = 10485770;
//const int maxN = 10;

const int maxV = 10*10 + 15;
const int maxE = maxV*maxV;

using namespace std;

ull gcd (ull a, ull b) {
    while (b) {
        a %= b;
        swap (a, b);
    }
    return a;
}

bool overflow(ull a, ull b)
{
    return b != (a*b)/a;
}

int main() {
    //ios_base::sync_with_stdio(false);             // notice!
    //freopen("input.txt", "r", stdin);

    ull t, a, b;
    cin >> t >> a >> b;

    ull k = gcd(a, b);
    ull ans;
    if (overflow(a/k, b)) ans = min(t+1, min(a, b));
    else {
        k = (a/k)*b;
        ans = (t/k) * min(a, b);
        ans += min(t%k+1, min(a,b));
    }
    ans--;

    //*
    ull g = gcd(ans, t);
    ans /= g;
    t /= g;
    //*/

    cout << ans << "/" << t << endl;

    return 0;
}

#include<iostream>
#include<string>
#include<map>
#include<vector>
using namespace std;
long long fun(long long a,long long b)
{
	long long c;
	if(a<b)
	{
		c=a;
		a=b;
		b=c;
	}
	if(a%b==0)
		return b;
	a=a%b;
	fun(a,b);
}
long long pp(long long a)
{
	int p=0;
	while(a)
	{
		p++;
		a/=10;
	}
	return p;
}
int main()
{
	long long t,w,b,k,s=0;
	cin>>t>>w>>b;
	if(w==b||(t<w&&t<b))
	{
		cout<<"1/1"<<endl;
		return 0;
	}
	long long kpp=fun(w,b);
	k=w*(b/kpp);
	long long kp=k;
	k=t/(w*(b/kpp));
	long long po=pp(w)+pp(b/kpp);
	if(po<=20)
	{
		s=(k-1)*min(w,b);
		s=s+min(min(w,b),t%kp+1);
	}
	s+=min(w,b)-1;
	if(s==0)
	{
		cout<<"0/1"<<endl;
		return 0;
	}
	long long kk=fun(s,t);
	cout<<s/kk<<"/"<<t/kk<<endl;
	return 0;
}

#include <iostream>
#include <string>
#include <map>
#include <set>
#include <stack>
#include <vector>
#include <algorithm>

typedef long long ll;
typedef unsigned long long ul;

using namespace std;

ul gcd(ul a, ul b) {
	while (b) {
		a %= b;
		swap(a, b);
	}
	return a;
}

ul lcm(ul a, ul b, ul t) {
	ul tmp = (a / gcd(a, b));
	if (t / tmp >= b)
		return tmp * b;
	return 0;
}

void solve()
{
	ul t, w, b;
	cin >> t >> w >> b;
	ul tmp1 = lcm(w, b, t);
	ul z,tmp2 = min(w, b) - 1;
	ul p, q = t;
	z = tmp1;
	if (tmp1 == 0)
	{
		p = min(tmp2, t);
	}
	else
	{
		p = t / z;
		p *= (tmp2 + 1);
		z = min(t % z, tmp2);
		p += z;
	}
	tmp2 = gcd(p, q);
	cout << (p / tmp2) << "/" << (q / tmp2);
}

int main()
{
	solve();
	return 0;
}

#include <iostream>
#include <stdio.h>
#include<stdlib.h>
#include <math.h>
#include<algorithm>
using namespace std;
typedef long long ll;
ll gcd(ll a,ll b)
{
    return b? gcd(b,a%b):a;
}
ll lcm(ll a,ll b)
{
    return a*(b/gcd(a,b));
}
int main()
{
    ll t,w,b;
    cin>>t>>w>>b;
    if(w==b)
        cout<<"1/1"<<endl;
    else if(log(w*1.0/gcd(w,b)*(double)b)>log((double)t))
    {
        ll s=min(t,min(w-1,b-1)),x=gcd(s,t);
        cout<<s/x<<'/'<<t/x<<endl;
    }
    else
    {
        ll min0=min(w,b)-1,gg=lcm(w,b),s=min0;
        //cout<<"s:"<<s<<endl;
        //cout<<"lcm:"<<gg<<endl;
        ll x=t/gg;
        //cout<<"t/lcm:"<<x<<endl;
        //cout<<"s:"<<s<<endl;
        s+=(x-1)*(min0+1);
        s+=min(t-x*gg+1,min0+1);
        //cout<<"t-x*gg:"<<t-x*gg<<endl;
        gg=gcd(s,t);
        cout<<s/gg<<'/'<<t/gg<<endl;
    }
    return 0;
}

///注意：会暴long long
///
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;

long long gcd(long long x, long long y)
{
    if(!y) return x;
    return gcd(y, x%y);
}

int main(void)
{
    long long t, w, b;

    while(~scanf("%I64d%I64d%I64d", &t, &w, &b))
    {
        if(w > b)
        {
            long long tm = w;
            w = b;
            b = tm;
        }
        if(w == b || t < w)
        {
            printf("1/1\n");
            continue;
        }
        long long tmp = gcd(w, b);
        long long mul = w/tmp*b;
        double tt = 1.0*w/tmp*b;
        long long temp;
        if(tt > 5e18)
        {
             temp  = w-1;
        }
        else
        {
            int ans = 0;
//            if(t < mul)
//            {
//                tmp = gcd(t, w-1);
//                printf("%I64d/%I64d\n", (w-1)/tmp, t/tmp);
//                continue;
//            }
            long long MIN = w;
            MIN--;
            temp = (t/mul)+(t/mul)*MIN;
            if((t/mul)*mul+MIN <= t) temp += MIN;
            else temp += (t-(t/mul)*mul);
        }
        tmp = gcd(temp, t);
        printf("%I64d/%I64d\n", temp/tmp, t/tmp);
    }
    return 0;
}

#include<iostream>
#include<algorithm>
#include<queue>
#include<string>
#include<vector>
#include<map>
#include<list>
#include<set>
#include<cstring>
#include<ctime>
#include<cmath>
#include<stack>
#define ll long long int
#define ull unsigned long long int
using namespace std;

ll gcd(ll a, ll b) {
	if (a == 0)
		return b;
	else
		return gcd(b % a, a);
}

int main() {
#pragma warning(disable : 4996)
#ifdef _DEBUG
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#define __builtin_popcount __popcnt
#endif
	ll t, w, b, ans = 0, g, mn;
	scanf("%lld%lld%lld", &t, &w, &b);
	g = gcd(w, b);
	mn = min(w, b);

	if (w / g > t / b) {
		ans = min(t, mn - 1 + (w == b));
	}
	else {
		g = b / g * w;
		ans += (t / g) * (mn);
		ll tt = (t % g);
		ans += min(tt, mn- 1);
	}

	g = gcd(ans, t);
	ans /= g;
	t /= g;
	printf("%lld/%lld", ans, t);

	return 0;
}

#include <iostream>
#include <algorithm>
using namespace std;

template<typename T>T gcd(T x, T y) { if(y == 0)return x; else return gcd(y, x%y); }

int main() {
    typedef unsigned long long ull;
    //lcm(w,b) x + y (0 <= y < min(w,b))
    ull t, w, b;
    while(cin >> t >> w >> b) {
        ++ t;
        ull g = gcd(w, b);
        ull num = 0;
        ull l = w / g * 1. * b < 1e19 ? w / g * b : (ull)1e19;
        ull r = t / l;
        num += r * min(w, b);
        num += min(t % l, min(w, b));
        -- num, -- t;
        ull h = gcd(num, t);
        cout << num / h << "/" << t / h << endl;
    }
    return 0;
}

#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <iostream>
#include <queue>
#include <map>
#include <set>
#include <vector>
using namespace std;

long long MaxY(long long a, long long b)
{
	long long x;

	if (a == 0)return 0;
	if (b == 0)return 0;

	while (b)
	{
		x = a % b;
		a = b;
		b = x;
	}
	return a;
}
long long MinY(long long a, long long b)
{
	if (a == 0)return 0;
	if (b == 0)return 0;
	long long max = MaxY(a, b);
	double ans = a / max;
	ans *= b;
	return ans;
}

int main()
{
	long long t = 0;
	long long w = 0;
	long long b = 0;
	cin >> t>> w>> b;
	long long min = w < b ? w:b;
	if (w == b) {
		cout << 1 << '/' << 1;
	}else if (t < min) {
		cout << 1 << '/' << 1;
	}else if (t == min) {
		cout << t - 1 << '/' << t;
	}
	else {
		long long minbeishu = MinY(w, b);
		long long times = t / minbeishu;
		long long left = t% minbeishu;
		long long ans = times*min;
		ans += left < min ? left : min - 1;
		long long maxyueshu = MaxY(ans, t);
		if (maxyueshu == 0) {
			cout << 0 << '/' << 1;
		}
		else {
			t = t / maxyueshu;
			ans = ans / maxyueshu;
			cout << ans << '/' << t;
		}

	}

}

#include <bits/stdc++.h>
using namespace std;
#define fl(i,a,b) for(int i=a;i<b;i++)
#define ll long long
#define endl '\n'
#define pb push_back
#define ff first
#define ss second
#define mod 1000000007
#define mx 1005
#define inf 1e17
#define fast ios_base::sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL);
// to check the overflow in LCM. LCM > T doesn't make any sense here
bool isOverflow(long double a, long double b)
{
	if(a> 6*(1e18)/b)
	{
		return 1;
	}
	return 0;
}
void print(ll x,ll y)
{
	ll gcdxy = __gcd(x,y);
	x/=gcdxy;
	y/=gcdxy;
	cout<<x<<"/"<<y;
}
main()
{
    ll t,w,b;
	cin>>t>>w>>b;
	ll gcd = __gcd(w,b);
	if(isOverflow(w/gcd,b))
	{

		if(min(w,b)>=t) // no one can take any step
		{
			cout<<"1/1";
		}
		else            // no one can take any step upto min(w,b)-1
		{
			unsigned ll x = min(w,b)-1;
			unsigned ll y = t;
			print(x,y);

		}
	}
	else
	{
	    ll leastCommonMultiple = w/gcd*b;
	    ll lastCommonMultiple  = t/leastCommonMultiple*leastCommonMultiple;
	    ll numerator = (t/leastCommonMultiple + 1)*min(w,b) -1 ;
	    ll denominator = t;
		// only numbers < t should be included
		if(lastCommonMultiple+min(w,b)-1>t)
		{
			numerator -= lastCommonMultiple + min(w,b) - 1 - t;
		}

		print(numerator,denominator);
	}
}

#include <iostream>
#include <bits/stdc++.h>
#include <cmath>
#include <string>
using namespace std;
#define fast                                                                   \
ios_base::sync_with_stdio(0);                                                \
cin.tie(0);                                                                  \
cout.tie(0);
#define ll long long
#define f(i, n) for (i = 0; i < n; i++)
#define F first
#define S second
#define pb push_back
#define pll pair<long long, long long>
#define vl vector<long>
#define mp make_pair
const int mod  = 1e9+7;
const int N  = 1000;

ll gcd(ll int a, ll int b) {
    if(!b)return a;
    return gcd(b,a%b);
}

ll lcm(ll int a, ll int b) {
    if(a < b)
    return a*b/gcd(a,b);
    else return a*b/gcd(b,a);
}

int main() {
    fast
    ll t, w, b, k, p, q, r, c1 = 0, c2, c3;
    cin>>t>>w>>b;
    //p= lcm(w,b);
    q = w<b? gcd(w,b) : gcd(b,w);
    double s = 1;
    s = s*w*b/q;
    if(s > t){
        c1 = min(min(w,b)-1,t);
       /// return 0;
    }
    else{
        p = w/q*b;
        c1 = min(w,b)*(t/p);
        //cout<<c1<<endl;
        c1 += min(min(w,b)-1,t%p);
       // cout<<c1<<endl;
    }
    if(c1 < t)
    q = gcd(c1,t);
    else
    q = gcd(t,c1);
    c1 /= q;
    t /= q;
    cout<<c1<<"/"<<t;
    return 0;
}

#include <iostream>
#include <string.h>
#include <vector>
#include <algorithm>
#include <stdio.h>
#include <map>
using namespace std;

long long usg(long long a, long long b)
{
    if (a == 0)
        return b;
    return usg(b%a, a);
}

int main()
{
    long long t, w, b;
    cin>>t>>w>>b;
    long long usgg=usg(max(w, b), min(w, b));
    long long part=w/usgg;
    part=t/part;
    part=part/b;
    long long pp1=w/usgg;
    long long pp2=b/usgg;
    long long gvawyobs1=min(t-part*usgg*pp1*pp2, min(b, w)-1);
    gvawyobs1+=part;
    if(part-1>=0)gvawyobs1+=part*(min(b, w)-1);
    long long usgg2=usg(t, gvawyobs1);
    gvawyobs1/=usgg2;
    t/=usgg2;
    cout<<gvawyobs1<<"/"<<t<<endl;
    return 0;
}

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define min(a,b) (a>b?b:a)
#define LL long long
using namespace std;
LL gcd(LL a,LL b)
{
    return b==0 ? a:gcd(b,a%b);
}
int main(void)
{
    LL t,b,w,ans = 0,lcm,Gcd;
    scanf("%lld%lld%lld",&t,&b,&w);
    Gcd = gcd(b,w);
    if(b*1./Gcd*w > (double)t)
        ans = min(t,min(b-1,w-1));
    else
    {
        lcm = w/Gcd*b;
        ans = t/lcm*min(w,b);
        ans += min(t%lcm,min(w,b)-1);
    }
    Gcd = gcd(ans,t);
    printf("%lld/%lld\n",ans/Gcd,t/Gcd);
    return 0;
}

#include <bits/stdc++.h>

#define ll long long

const int N = 1e5 + 10;
const int MOD = 1e9 + 7;
const ll INF = 9e18;

using namespace std;

ll product(ll x, ll y)
{
    if (INF / x < y) return INF;
    else return x * y;
}

ll lcm(ll x, ll y)
{
    return product(x / __gcd(x, y), y);
}

int main()
{
    ios::sync_with_stdio(false);
    ll t, w, b;
    cin >> t >> w >> b;
    ll l = lcm(w, b);
    ll p = t, q;
    ll m = min(w, b);
    cerr << l << endl;
    q = min(t, m - 1);
    if (l <= t) q += (t / l - 1) * m + min(t % l + 1, m);
    cerr << q << " " << p << endl;
    w = __gcd(p, q);
    q /= w;
    p /= w;
    cout << q << "/" << p;
    //cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
    return 0;
}

#include <bits/stdc++.h> /**  I'm Klaus, NicKlaus :v **/
using namespace std;
#define ms(a,v) memset(a,v,sizeof a)
#define ll long long
ll gcd(ll x, ll y){return (y ? gcd(y, x%y) : x); }
ll lcm(long double x, long double y){return x*(y/gcd((ll)x,(ll)y));}
int main(){
	ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	#ifdef LOCAL_JUDGE
		//freopen("in_out/in.txt", "rt", stdin);
		//freopen("int_out/out.txt", "wt", stdout);
	#endif
	ll t, a, b;
	cin>>t>>a>>b;
	ll l = lcm(a,b);
	ll ans = t/l;
	ll x = min(a,b)-1;
	ans = ans + x*ans;
	ans += (min(t-l*(t/l),x));
	if( t< min(a,b)){
		ans = t;
	}
	while(gcd(ans,t) != 1ll){
		ll aux = gcd(ans,t);
		ans/=aux;
		t/=aux;
	}
	cout<<ans<<"/"<<t<<endl;
	return 0;
}

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair <int, int> ii;
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <ii> vii;
typedef vector <vii> vvii;
#define endl '\n'
#define PB push_back
#define MP make_pair
#define OO (1000000000)
#define EPS (1e-9)
#define MOD (1000000007)
#define all(v) ((v).begin()),((v).end())
#define DEBUG(x) cout<< #x <<" = "<<"\""<< (x) <<"\""<<endl
#define FASTIO ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
void read_file(bool outToFile = true){
#ifdef LOCAL_TEST
    #define LL "%lld"
    freopen("in.in", "rt", stdin);
    if(outToFile)
    freopen("out.out", "wt", stdout);
#else
    #define LL "%I64d"
#endif
}
//
ll a, b, c;
//
ll gcd(ll a, ll b){
    return a == 0? b : gcd(b%a, a);
}
ll russian_peasant(ll a, ll b){
    ll z = 0;
    bool willOverflow = false;
    while(a != 0)
    {
        if(a%2 == 1)
        {
            /*if(willOverflow) { z = c+1; break; }
            z += b;
            if(1ULL*2*b + z > c) willOverflow = true;*/
            z += b;
            if(a != 1 && 1ULL*2*b + z > c) { z = c+1; break; }
        }

        a /= 2;
        b *= 2;
    }
    return z;
}
//
int main()
{
    read_file();
    while(cin>>c>>a>>b)
    {
        if(a > b) swap(a, b);
        if(a == b) { printf("1/1\n"); continue; }

        ll l = russian_peasant(a/gcd(a, b), b);
        if(l > c)
        {
            ll ans = min(a-1, c);
            ll g = gcd(ans, c);
            printf(LL"/"LL"\n", ans/g, c/g);
            continue;
        }

        ll z = c/l;
        ll ans = (z-1)*a + (a-1) + min(c - z*l + 1, a);

        ll g = gcd(ans, c);
        printf(LL"/"LL"\n", ans/g, c/g);
    }
}

#include<stdio.h>
#include<vector>
#include<algorithm>
#include <iostream>
#include <cmath>
#include <complex>
#include<queue>
#include <string>
#include<bits/stdc++.h>
#define pi 3.14159265
using namespace std;
typedef long long  ll;
typedef pair<ll, ll>pii;
template<typename T>T gcd(T x, T y) { if(y == 0)return x; else return gcd(y, x%y); }
//typedef bitset<8> mask;
//int x[8]={1,0,0,-1,-1,-1,1,1};
//int y[8]={0,1,-1,0,-1,1,-1,1};
//const double PI = acos(-1.0);
//const double EPS = 1e-9;
//typedef complex<double> point;
ll t,w,b,ans,g,f;
int main()
{
    //cout<<Pow((ll)1000000,(ll)110);
//freopen("hotel.in","r",stdin);
//freopen("math.in","w",stdout);
//printf("%s %.4f\n",k.c_str(),g);
cin>>t>>w>>b;
if(t<w&&t<b)
{
    cout<<"1/1";
    return 0;
}
g=gcd(w,b);
ll c;
if(8*1e18/(w/g)<b)
 c=8*1e18;
else
 c=w/g*b;
ll n=t/c;
ans+=n*min(w,b);
ll f=(t/c)*c;
if(f+min(b-1,w-1)>t)
ans-=(f+min(b-1,w-1))-t;
ans+=min(b-1,w-1);
ll k=gcd(ans,t);
cout<<ans/k<<"/"<<t/k;

return 0;
}

#include<bits/stdc++.h>

using namespace std;

unsigned long long t,w,b,ans;

int main()
{

    cin>>t>>w>>b;
    if(w<b) swap(w,b);
    if(t<b || w==b) {puts("1/1");return 0;}
    ans+=b-1;
    unsigned long long gd=__gcd(w,b);
    long double g=t/w;
    if((b/gd)<=g)
    {
        unsigned long long lm=(w/gd)*b;
        ans+=(long long)(t/lm)*b;
        if(((t/lm)*lm+b-1)>t) ans-=((t/lm)*lm+b-1)-t;
        gd=__gcd(ans,t);
        cout<<ans/gd<<"/"<<t/gd;
    }
    else
    {
        gd=__gcd(ans,t);
        cout<<ans/gd<<"/"<<t/gd;
        //cout<<"0/"<<"1";
    }
    return 0;
}

#include<bits/stdc++.h>

#define ll long long
#define pi 3.141592
#define nl printf("\n")
#define f(i,l1,l2) for(i=l1;i<l2;i++)
#define gc getchar_unlocked
#define vi vector<int>
#define vit vi::iterator
#define all(c) c.begin(), c.end()
#define pb push_back
#define endl "\n"
#define mp make_pair
using namespace std;

/*void fin(int &x)       //does not compile in codeblocks but does in online judges
{                        //use if input too large ( only for integers )
int i=0;x=0;
register int c=gc();
while(c<48||c>57)
c=gc();
while(c>47&&c<58)
{
x=(x<<1)+(x<<3) + c-48;
i++;
c=gc();
}
}*/
ll gcd(ll m, ll n)
{
    if(n==0)
        return m;
    return gcd(n,m%n);
}
int main()
{
    std::ios::sync_with_stdio(false);
    cin.tie(0);
    int i,n,e;
    ll t,w,b;
    cin>>t>>w>>b;

    // 9 3 3
    ll lcm = (w/gcd(w,b));
    ll mul = (t/b)/lcm;
    cerr<<gcd(w,b)<<endl;
    cerr<<mul<<endl;
    if(mul>=1&&w!=b)
    {
        ll p = min(w,b);

        ll num = mul*(p-1) + p-1 + mul;
        if(t-(((w/gcd(w,b))*b)*mul)<p-1)
        {
            cerr<<"prev "<<num<<endl;
            num = num - (p-1-(t-(((w/gcd(w,b))*b)*mul)));
        }
        cerr<<num<<endl;

        ll x = gcd(num,t);
        cerr<<x<<endl;
        cout<<num/x;
        cout<<"/";
        cout<<t/x;

    }
    else
    {
        if(w==b)
            cout<<"1/1";
        else
        {
            ll p = min(w,b);
            if(p<=t)
            {
                ll x = gcd((p-1),t);
                cout<<(p-1)/x<<"/"<<t/x;
            }
            else
                cout<<"1/1";

        }
    }
    return 0;
}

#include <cstdio>
#include <cmath>
#include <cctype>
#include <cstring>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
#include <functional>

#define X 9
#define INF (1<<30)
#define LL long long
#define eps 1e-4

LL gcd(LL a, LL b)
{
	return (b>0)?gcd(b, a%b):a;
}
int main()
{
	LL ans = 0, l, w, b, lcm, tmp;
	scanf("%I64d%I64d%I64d", &l, &w, &b);
	if(w > b)	w ^= b ^= w ^= b;
	tmp = gcd(w, b);
	lcm = l/w/(b/tmp);
	if(lcm < 1)
		ans = std::min(w-1, l);
	else
	{
		lcm = w/tmp*b;
		ans = l/lcm*w+std::min(w-1, l%lcm);
	}
	tmp = gcd(ans, l);
		printf("%I64d/%I64d\n", ans/tmp, l/tmp);
	return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define ll unsigned long long
int main(){
ll t, w, b, lcm;
cin>>t>>w>>b;

if(b%w==0)lcm=b;
else if(w%b==0)lcm=w;
else {
lcm = b*w/__gcd(b, w);

if(lcm*__gcd(b, w)/b != w)
    lcm = t+1;
}

ll p = min(b, w) * (t/lcm) +
min(t % lcm + 1LL, min(w, b)) -1LL ;

if(p == 0){
    cout<<"0/1";
    return 0;
}

cout<<p/__gcd(p, t)<<"/"<<t/__gcd(p, t);
}

//Copyrights of the Code reserved with chetan_shukla
#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<long long> vll;
typedef vector<pii> vpii;
#define f first
#define s second
#define mp make_pair
#define pb push_back
#define MOD 1000000007
long long GCD(long long a ,long long b)
{
    return b?GCD(b,a%b):a;
}
int POW(int Base, int Exp)
{
    int y,ret=1;
    y=Base;
    while(Exp)
    {
        if(Exp&1)
                ret=(ret*y)%MOD;
        y = (y*y)%MOD;
        Exp/=2;
    }
    return ret%MOD;
}
//int A[100007],Marked[100007];
int main()
{
    long long t,w,b;
    cin>>t>>w>>b;
    long long Ans1,Ans2;
    long long gcdwb = GCD(w,b);
    long long Min = min(w,b);
    long long Max = max(w,b);
    long long tmp,lcm;
    if((t/Min >= Max/gcdwb) && t>=Max)
    {
        lcm = (Max/gcdwb)*Min;
        //cout<<"gcdwb: "<<gcdwb<<endl;
        //cout<<"lcm: "<<lcm<<endl;
        tmp = t/lcm;
        tmp+= tmp*(Min-1);
        tmp+= min(Min-1,t%lcm);
    }
    else
    {
        tmp = min(Min-1,t);
    }
    Ans1 = tmp;
    Ans2 = t;
    //cout<<Ans1<<"/"<<Ans2<<endl;
    long long gcd12 = GCD(Ans1,Ans2);
    Ans1/=gcd12;
    Ans2/=gcd12;
    cout<<Ans1<<"/"<<Ans2<<endl;
    return 0;
}

#include <bits/stdc++.h>

using namespace std;
typedef long long INT;

void calc(INT x,INT y){
	y=x-y;
	y=min(y,x);
	INT z=__gcd(x,y);
	printf("%I64d/%I64d\n",y/z,x/z);
}

int main() {
#ifndef ONLINE_JUDGE
	freopen("in.in", "r", stdin);
	freopen("out.out", "w", stdout);
#endif
	INT s,w,b;
	scanf("%I64d %I64d %I64d",&s,&w,&b);
	if(b>w) swap(b,w);
	INT g=__gcd(b,w);
	INT d=b/g;
	if(d>s/w) calc(s,s-b+1);
	else{
		d*=w;
		calc(s,(d-b)*(s/d)+max(0LL,s%d-b+1));
	}
	return 0;
}

#include<bits/stdc++.h>
#define ll long long
#define int_max 1000000001
#define sc(x) scanf("%d",&x)
#define scl(x) scanf("%lld",&x)
#define sc3(x,y,z) scanf("%d %d %d",&x,&y,&z)
#define endl "\n"
#define vi vector<int>
#define vii vector<pair<int,int>>
#define mp(x,y) make_pair(x,y)
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define instr(str) string str; cin>>str;
#define loop(i,x,y) for(int i = x; i < y ; i++ )
#define pr(arr)    for(int i = 0 ; i < arr.size() ; i++){cout<<arr[i]<<endl;} cout<<endl;
#define pr1(arr)   for(int i = 1;i < arr.size(); i++){cout<<arr[i]<<endl;}cout<<endl;
#define in(n)       int n; cin>>n;
#define inll(n)       ll n; cin>>n;
#define tc int t;cin>>t;while(t--)
#define inarr(arr,n) int arr[n]; for(int i = 0; i < n ; i++){cin>>arr[i];}
#define inarr1(arr,n) int arr[n]; for(int i = 1; i < n ; i++){cin>>arr[i];}
using namespace std;
ll gcd(ll a,ll b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}
ll min1 (ll a,ll b)
{
    if(a<b)
        return a;
    else
        return b;
}
ll n,a,b;
int main()
{
cin>>n>>a>>b;
    ll gc=__gcd(a,b);
    ll lcm = (long double)a/gc*b;
//cout<<lcm<<endl;
ll x = n/lcm;
//cout<<x<<endl;
ll z = n%lcm;
if(z>=min1(a,b)-1)
{
    ll u=min1(a,b)-1+x*min1(a,b);
    ll p = gcd(u,n);
    cout<<u/p<<"/"<<n/p<<endl;
}
// 3000000000000000000
// 2999999999999999873
// 600000000000000000
else
{
    ll u =min1(a,b)+(x-1)*min1(a,b) + z;
    ll p = gcd(u,n);
    cout<<u/p<<"/"<<n/p<<endl;
}

}

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double ld;
typedef pair <ll, ll> pll;
#define pb push_back
#define mp make_pair
#define all(_) _.begin(), _.end()

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);

    ll w, b, t;
    cin >> t >> w >> b;

    if (w > b) swap(w, b);
    b /= __gcd(w, b);

    ll lim = (ll) 5e18, q = t, p, mul = (t/b)/w;
    if ((lim/b)/w != 0) {
        p = (w - 1) + (mul - 1)*w + min(1 + t % (w * b), w);
    } else {
        p = min(w - 1, t);
    }

    ll gc = __gcd(p, q);
    cout << p/gc << '/' << q/gc << '\n';
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
int main()
{
    //freopen("input.txt", "r", stdin);
    long long n,a,b;
    cin >> n >> a >> b;
    if (n<a && n<b)
    {
        cout << "1/1";
        return 0;
    }
    long long ch = a/__gcd(a,b)*b;
    if (ch<=0 || ch%a!=0 || ch%b!=0)
    {
        long long o = min(a,b)-1;
        long long c = __gcd(o,n);
        cout << o/c << "/" << n/c;
        return 0;
    }
    //cout << ch << endl;1
    long long o = min(a,b)-1, kop = n;
    if (ch<=n)
    {
        o += min(n%ch,min(a,b)-1)+1;
        n -= n%ch+1;
    }
    //cout << n << " " << ch << " " << n/ch*(min(a,b)) << endl;
    o += n/ch*(min(a,b));
    n = kop;
    long long c = __gcd(o,n);
    cout << o/c << "/" << n/c;
}

#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
using ull = unsigned long long;
inline ull gcd(ull a, ull b) { return b ? gcd(b, a % b) : a; }

inline ull lcm(ull a, ull b, ull t) {
    if (1.0 * a / gcd(a, b) * b > ~1ULL) return t + 1;
    return a / gcd(a, b) * b;
}

int main() {
    ull t, a, b; cin >> t >> a >> b;
    if (a > b) swap(a, b);
    if (a > t) return !(cout << "1/1" << endl);
    ull l = lcm(a, b, t);
    ull ans = t / l * a + min(a - 1, t % l);
    [&](ull x, ull y) {
        ull g = gcd(x, y);
        cout << x / g << "/" << y / g << endl;
    }(ans, t);
    return 0;
}

//DUEL
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#define x first
#define y second
#define pii pair<int,int>
#define pb push_back
#define eb emplace_back
#pragma GCC optimize("unroll-loops")
#define shandom_ruffle(a, b) shuffle(a, b, rng)
#define vi vector<int>
#define vl vector<ll>
#define popcnt __builtin_popcount
#define popcntll __builtin_popcountll

using namespace std;
using namespace __gnu_pbds;

using ll=long long;
using ull=unsigned long long;
using ld=long double;
int MOD=1000000007;
int MOD2=998244353;
vector<int> bases;
const ll LLINF=1ll<<60;
const char en='\n';

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void yes() {cout<<"YES"<<en; exit(0);}
void no() {cout<<"NO"<<en; exit(0);}
inline int rund() {int x576363482791fuweh=rng();return abs(x576363482791fuweh)%RAND_MAX;}
template<class T>
void prVec(vector<T> w,bool fl=false)
{
	cout<<w.size()<<en;
	for (int i=0;i<int(w.size())-1;++i) cout<<w[i]<<' ';
	if (w.size()) cout<<w[w.size()-1]<<en;
	if (fl) cout<<flush;
}

void M998()
{
	swap(MOD,MOD2);
}

ll raand()
{
	ll a=rund();
	a*=RAND_MAX;
	a+=rund();
    return a;
}

#define rand raand

ll raaand()
{
	return raand()*(MOD-7)+raand();
}

string to_upper(string a)
{
	for (int i=0;i<(int)a.size();++i) if (a[i]>='a' && a[i]<='z') a[i]-='a'-'A';
	return a;
}

string to_lower(string a)
{
	for (int i=0;i<(int)a.size();++i) if (a[i]>='A' && a[i]<='Z') a[i]+='a'-'A';
	return a;
}

ll sti(string a,int base=10)
{
	ll k=0;
	for (int i=0;i<(int)a.size();++i)
	{
		k*=base;
		k+=a[i]-'0';
	}
	return k;
}

template<class T>
void eras(vector<T>& a,T b)
{
	a.erase(find(a.begin(),a.end(),b));
}

string its(ll k,int base=10)
{
	if (k==0) return "0";
	string a;
	while (k)
	{
		a.push_back((k%base)+'0');
		k/=base;
	}
	reverse(a.begin(),a.end());
	return a;
}

ll min(ll a,int b)
{
	if (a<b) return a;
	return b;
}

ll min(int a,ll b)
{
	if (a<b) return a;
	return b;
}

ll max(ll a,int b)
{
	if (a>b) return a;
	return b;
}

ll max(int a,ll b)
{
	if (a>b) return a;
	return b;
}

ll gcd(ll a,ll b)
{
	if (b==0) return a;
	return gcd(b,a%b);
}

ll lcm(ll a,ll b)
{
	return a/gcd(a,b)*b;
}

template<class T,class K>
pair<T,K> mp(T a,K b)
{
	return make_pair(a,b);
}

inline int mult(ll a,ll b)
{
	return (a*b)%MOD;
}

inline int pot(int n,int k)
{
	if (k==0) return 1;
	ll a=pot(n,k/2);
	a=mult(a,a);
	if (k%2) return mult(a,n);
	else return a;
}

int divide(int a,int b)
{
	return mult(a,pot(b,MOD-2));
}

inline int sub(int a,int b)
{
	if (a-b>=0) return a-b;
	return a-b+MOD;
}

inline int add(int a,int b)
{
	if (a+b>=MOD) return a+b-MOD;
	return a+b;
}

bool prime(ll a)
{
	if (a==1) return 0;
	for (int i=2;i<=round(sqrt(a));++i)
	{
		if (a%i==0) return 0;
	}
	return 1;
}

const int N=300010;
ll n,a,b;

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	for (int i=0;i<10;++i) bases.push_back(rand()%(MOD-13893829*2)+13893829);
	cin>>n>>a>>b;
	ll g1=gcd(a,b);
	ll n1=n;
	++n;
	ll c1=n/a*g1/b*min(a,b);
	n=n-n/a*g1/b*a/g1*b;
	c1+=min(min(a,b),n);
	--c1;
	ll g=gcd(c1,n1);
	cout<<c1/g<<'/'<<(n1)/g;
}

#include <algorithm>
#include <iostream>
#include <vector>

long long gcd(long long a, long long b) {
    return b == 0 ? a : gcd(b, a % b);
}

long long lcm(long long a, long long b, long long t) {
	return t / (a / gcd(a, b)) < (b / gcd(a, b)) ? t + 1 : (a / gcd(a, b)) * b;
}

int main(){
	long long t, w, b; std::cin >> t >> w >> b;
	if (t < w && t < b) {
		std::cout << 1 << '/' << 1 << '\n';
		return 0;
	}
	if ((t < w && t >= b) || (t < b && t >= w)) {
		long long m = std::min(b, w);
		std::cout << ((m - 1) / gcd(m - 1, t)) << '/' << (t / gcd(m - 1, t)) << '\n';
		return 0;
	}
	long long MIN = std::min(w, b), LCM = lcm(w, b, t), times = t / LCM, res = 0;
	res = MIN * times + (t - LCM * times == 0 ? 0 : t - LCM * times >= MIN ? MIN - (t - LCM * times > 0) : t - LCM * times);
	std::cout << (res / gcd(res, t)) << '/' << (t / gcd(res, t)) << '\n';
}

#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>

#define LL long long
#define ULL unsigned long long
#define MID(x, y) (((x) + (y)) >> 1)
#define pb push_back

using namespace std;

const int inf = 0x3f3f3f3f;
const LL INF = 1e18;

LL t, w, b;

LL gcd(LL a, LL b)
{
    if (a < b) swap(a, b);
    //if (b == 0) return 1;尼玛的
    if(b==0)return a;
    while (a % b)
    {
        LL t = a % b;
        a = b;
        b = t;
    }
    return b;
}
int main()
{
    #ifdef LOCAL
    freopen("in", "r", stdin);
    #endif // LOCAL

    while (scanf("%I64d%I64d%I64d", &t, &w, &b) != EOF)
    {
        LL g = gcd(w, b);
        LL tmp = w / g;
        LL x = min(w, b);
        LL ans = min(t,x - 1);
        g = gcd(ans, t);
        if (t / tmp < b) printf("%I64d/%I64d\n", ans / g, t / g);
        else
        {
            tmp = tmp * b;  //lcm
            LL cnt = t / tmp;

            ans += x * cnt;
            LL jason = cnt * tmp + x - 1;
            if (jason > t) ans -= (jason - t);
            g = gcd(ans, t);
            printf("%I64d/%I64d\n", ans / g, t / g);
        }

    }

}

#include <iostream>
#include <vector>
#include <stdlib.h>
#include <string>
#include <algorithm>
#include <stdio.h>
#include <bits/stdc++.h>
#define mp make_pair

using namespace std;

typedef pair<int, int> pie;
long long gcd(long long a, long long b)
{
	if(b == 0)
		return a;
	return gcd(b, a % b);
}

long long t, w, b, gc = 0, ans = 0, scm = 0;

int main()
{
	cin >> t >> w >> b;
	if(w == b)
	{
		cout << "1/1" << endl;
		return 0;
	}
	if(log(w/ gcd(w,b)) + log(b) > log(t) + 1)
	{
		ans = min(min(b, w) - 1, t);
		gc = gcd(ans , t);
		cout << ans / gc << '/' << t / gc << endl;
		return 0;
	}
	scm = (w / gcd(w, b)) * b;
	if(t < scm)
	{
		ans = min(t, min(b, w) - 1);
		cout << ans / gcd(ans, t) << '/' << t / gcd(ans, t) << endl;
		return 0;
	}
	t -= scm;
	ans += min(w, b) - 1;
	ans += t / ((b / gcd(b, w)) * w) * min(b, w);
	gc = t % scm;
	ans += min(gc + 1, min(b, w));
	t += scm;
	cerr << ans << " " << gc << endl;
	long long temp = gcd(t, ans);
	cout <<  ans / temp  << "/" << t / temp << endl;
}

#include<iostream>
#include<algorithm>
#include<fstream>
using namespace std;
typedef long long ll;
const int maxn = 10;
long long gcd(long long x, long long y)
{
    if (!y) return x;
    return gcd(y, x%y);
}
int main()
{
    ll t, w, b;
    cin >> t >> w >> b;
    ll g = gcd(w, b);
    ll mi = min(w, b);
    double lcm = 1.0*(w / g)*b;
    ll tie;
    if (lcm > 5e18)
        tie = min(t, mi - 1);
    else
    {
        ll LCM = w / g*b;
        tie = (t / LCM)*mi;//乘以mi是因为在lcm~lcm+mi内都是平局的
        tie += min(t%LCM, mi - 1);
    }
    ll gg = gcd(tie, t);
    cout << tie / gg << "/" << t / gg << endl;
    return 0;
}

/*
######################################################
#    I don't know what I'm doing with my life O.O    #
######################################################
*/

#include <bits/stdc++.h>
using namespace std;

//Optimizations
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

//save time
#define endl '\n'
#define db(x) cerr << "> " << #x << ": " << x << endl;
typedef long long ll;

//for sorting
#define all(a) a.begin(),a.end()

//Constants
#define PI   3.141592653593
#define MOD  1000000007LL
#define EPS  0.000000001
#define INF  0X3f3f3f3f

//loops
#define REP(i,n) 	    for(int i=0;i<(n);++i)
#define FOR(i,a,b)      for(int i=(a);i<(b);++i)
#define DFOR(i,a,b)     for(int i=(a);i>=(b);--i)

//vectors
#define vi vector<int>
#define vll vector<ll>
#define vii vector<pair<int,int>>
#define vlll vector<pair<ll,ll>>
#define pb 	push_back

//pairs
#define pi pair<int,int>
#define pll pair<ll,ll>
#define mp make_pair
#define F first
#define S second

//fast I/O
#ifndef _WIN32
#define getchar getchar_unlocked
#define putchar putchar_unlocked
#endif
#define gc getchar
#define pc putchar

//If using cin and cout
#define IOS ios::sync_with_stdio(false)
#define TIE cin.tie(NULL);cout.tie(NULL)

//queue
#define di deque<int>
#define dll deque<ll>
#define qi queue<int>
#define PQ priority_queue

//general
#define E empty()

//Declare all variables and methods needed between this comment and the next one(OCD lol)
const int MAXN=0;
//Main function
int main(){
    IOS;
    TIE;

    ll l,a,b;
    cin>>l>>a>>b;

    ll gcd=__gcd(a,b);
    ll lcm=(a/gcd)*b;

    double fuckMyLife=double(a)*double(b)/double(gcd);
    ll num=1,ans=0;
    if(fuckMyLife<=5e18)
        num+=(l/lcm);

    db(fuckMyLife);
    db(lcm);
    db(num);
    if(num>1){
        ans+=((num-1)*min(a,b)-1);
        ans+=min(min(a,b),l%lcm+1);
    }
    else
        ans=min(a-1,min(b-1,l));

    gcd=__gcd(ans,l);
    cout<<(ans/gcd)<<"/"<<l/gcd<<endl;

    return 0;
}

#include <bits/stdc++.h>
using namespace std;
int main(){
unsigned long long x, y,tmp, z, t2, res;
while(cin>>z>>x>>y){
    tmp=__gcd(x, y);
    if(z/x*tmp<y){
        tmp=z+1;
    }
    else{

        if(x>y)
            tmp=x/tmp*y;
        else
            tmp=y/tmp*x;
    }
    t2=((z)/tmp);
    res=(t2+1)*min(x, y)-1;
    if(z<(t2*tmp+min(x,y)-1)){
        res-=(t2*tmp+min(x,y)-1)-z;
    }
    x=__gcd(z, res);
    res/=x;
    z/=x;
    cout<<res<<"/"<<z<<endl;
}
return 0;
}

#define REP(a,b) for(int a=0; a<(b); ++a)
#define REP2(a, b) for(int a=1; a<=(b); ++a)
#define FWD(a,b,c) for(int a=(b); a<(c); ++a)
#define BCK(a,b,c) for(int a=(b)-1; a>=(c); --a)
#define BCK2(a,b,c) for(int a=(b); a>(c); --a)
#define FWDS(a,b,c,d) for(int a=(b); a<(c); a+=d)
#define ALL(a) (a).begin(), (a).end()
#define SIZE(a) ((int)(a).size())
#define VAR(x) #x ": " << x << " "
#define FILL(x,y) memset(x,y,sizeof(x))
#define FAST ios_base::sync_with_stdio(0);cin.tie(0);
#define x first
#define y second
#define st first
#define nd second
#define mp make_pair
#define pb push_back
#define l(n) (n<<1)
#define r(n) ((n<<1)+1)
#define f(n) (n>>1)
#define lsb(a) (a&-a)

#include<vector>
#include<stack>
#include<queue>
#include<algorithm>

using namespace std;
#include<iostream>

const int NMAX = 5005;
const int MOD = 1000000007;
const int INF = 100000000;
const int dx[] = {0, 1, 0, -1}; //1,1,-1,1};
const int dy[] = {-1, 0, 1, 0}; //1,-1,1,-1};
typedef long long LL;
typedef pair<int, int> PII;
typedef long double K;
typedef pair<K, K> PKK;
typedef vector<int> VI;

LL gcd(LL a, LL b)
{
    if(!b) return a;
    return gcd(b, a%b);
}

LL n,w,b,l;

int main(){
	cin>>n>>w>>b;
	double lc=w/gcd(w,b);
	lc*=b;
	l=lc;

	LL s = 1LL*(n/l)*(min(w,b)) + min(min(w,b)-1,n%l);

	cout<<1LL*s/gcd(n,s)<<"/"<<1LL*n/gcd(n,s)<<"\n";
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

typedef long long int64;
typedef pair<int64, int64> frac;
#define mp make_pair
#define num first
#define denom second

int64 lcm(int64 a, int64 b) {
  if((double)a/__gcd(a,b)*b > 5*1e18) return -1;
  return a/__gcd(a,b)*b;
}

int64 plafon(int64 a, int64 b) {
  if (a%b == 0) return a/b;
  else return a/b+1;
}

int64 pod(int64 a, int64 b) {
  return a/b;
}

frac reduce(frac x) {
  int64 GCD = __gcd(x.num, x.denom);
  return mp(x.num/GCD, x.denom/GCD);
}

int main() {
  int64 t, w, b; cin >> t >> w >> b;
  int64 mini = min(w, b);
  int64 LCM = lcm(w, b);
  frac sol;
  if (LCM == -1) {
    sol = mp(min(mini-1, t), t);
  } else {
    int64 nom = plafon(t, LCM) * (mini-1) + pod(t, LCM);
    int64 cap;
    if (t == pod(t,LCM)*LCM) cap = (pod(t,LCM)-1) * LCM + mini - 1;
    else cap = pod(t, LCM) * LCM + mini - 1;
    if (t < cap) nom -= cap - t;
    sol = mp(nom, t);
  }
  sol = reduce(sol);
  cout << sol.num << "/" << sol.denom << endl;
  return 0;
}

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
using namespace std;
#define MIN(a,b) ((a) < (b)) ? (a) : (b);
__int64 gcd(__int64 a, __int64 b)
{
    while (b ^= a ^= b ^= a %= b);
    return a;
}

int main()
{
    __int64 t, u, v;
    //freopen ("in.int","r",stdin);
    scanf("%I64d%I64d%I64d", &t, &u, &v);
    __int64 m = MIN(u, v);
    __int64 g = gcd(u, v);
    //cout<<g<<endl;
    double lcm =  (double)(u / g) *v;
    __int64 k ;
    if (lcm > t)
    {
        k = MIN(t,m-1);
    }
    else
    {
        k = (t / (__int64)lcm) *m;
        k += MIN(t % (__int64)lcm, m - 1);
    }
    __int64 gg = gcd(k, t);
    //cout<<k<<endl;
    printf("%I64d/%I64d\n", (k / gg),(t / gg));
    return 0;
}

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <cmath>
#include <stack>
#include <map>
#include <assert.h>
#include <bitset>
#include <string>
using namespace std;

unsigned long long gcd(unsigned long long a, unsigned long long b) {
	return b ? gcd(b, a % b) : a;
}

void output(unsigned long long n, unsigned long long m) {
	m = min(n, m);
	unsigned long long d = gcd(n, m);
	cout << (m / d) << "/" << (n / d) << endl;
	exit(0);
}

int main()
{
	unsigned long long n, x, y;
	cin >> n >> x >> y;
	if (x == y) {
		cout << "1/1" << endl;
		return 0;
	}

	unsigned long long d = gcd(x, y);
	if (n / (x / d) < y) {
		output(n, min(x - 1, y - 1));
	}

	unsigned long long lcm = x / d * y;
	unsigned long long ans = n / lcm * min(x - 1, y - 1) + n / lcm;
	unsigned long long m = n % lcm;
	ans += min(m, min(x - 1, y - 1));
	output(n, ans);
	return 0;
}

/*
जिन खोजा तिन पाइया, गहरे पानी पैठ,
मैं बपुरा बूडन डरा, रहा किनारे बैठ।
*/
#include<bits/stdc++.h>
#include<iostream>

using namespace std;

#define boost ios::sync_with_stdio(0);cin.tie(0);
#define forn(i,n) for ( int i=0 ; i < n ; i++ )
#define all(a) (a).begin(), (a).end()
#define lb lower_bound
#define ub upper_bound
#define vi vector<int >
#define pii pair<int, int>
#define F first
#define S second
#define MP make_pair
#define PB push_back
#define SQ(a) (a)*(a)
#define ll long long
#define lli long long int
#define ull unsigned long long
#define endl '\n'
#define Pi(a) printf("%d\n",a);
#define debug2(a,b) printf("%d\t%d\n",a,b);
#define debug1(a) printf("%d\n",a);
#define Si(a) scanf("%d",&a);
#define mod 1000000007
#define w(n) while(n--)
#define div divvv

bool getout(ll a,ll b){
	ll final=a*b;
	// cout << "came" << endl;
	//cout << a << " " << b << " " << final << endl;
	if(final==0){
		if(a==0||b==0) return false;
		return true;
	}
	else if(final/a!=b) return true;
	return false;
}

int main()
{
    boost
    //code
    ll n,w,d;
    long long nn, ww, dd;
    cin >> nn >> ww >> dd;
    n = nn;w=ww;d=dd;
    ll ans = min(n,min(w,d)-1);
    ll div = __gcd(w,d);

    if(n/w<d/div-1){
        ll num = min(n, min(w, d)-1), den = n;
        ll g = __gcd(num, den);
        cout << num / g << "/" << den / g << endl;
        return 0;
    }
    /*
   	if(getout(w,d/div)){
   		ll here = min(n,min(w,d)-1);
   		ll other = __gcd(here,n);
   		cout << here << "/" << n << endl;
   		return 0;
   	}
   	*/
   	div = w*(d/div);
    ans += max(0LL,((n/div) - 1)*(min(w,d)));
    if(n/div>=1)
    ans += min(w,min(d,n%div+1));
    //cout << ans << endl;
    ll other = __gcd(ans,n);
    cout << (long long)(ans/other) << "/" << (long long)(n/other) << endl;
    return 0;

}
/*
-> check for array out of bounds & array declaired before size input(runtime error)
-> check for int overflow, use ll
-> check for corner cases like 0
-> check for j++ in while loop for every case
-> use boost except for interactive problems
*/

# include <functional>
# include <algorithm>
# include <iostream>
//# include <hash_set>
//# include <hash_map>
# include <string.h>
# include <iterator>
# include <assert.h>
# include <utility>
# include <cstring>
# include <sstream>
# include <iomanip>
# include <bitset>
# include <string>
# include <cstdio>
# include <vector>
# include <deque>
# include <queue>
# include <stack>
# include <cmath>
# include <ctime>
# include <list>
# include <map>
# include <set>
//#pragma comment (linker, "/STACK:17000000")

#define mp make_pair
#define pb push_back
#define all(v) v.begin(),v.end()

using namespace std;

typedef long long ll;
typedef pair<int, int > P;
typedef long double db;

const db eps=1e-9, pi=acos(-1.0);
const ll inf=2000000009;

const int base = 1000000000;
const int base_digits = 9;

struct bigint {
    vector<int> a;
    int sign;

    bigint() :
        sign(1) {
    }

    bigint(long long v) {
        *this = v;
    }

    bigint(const string &s) {
        read(s);
    }

    void operator=(const bigint &v) {
        sign = v.sign;
        a = v.a;
    }

    void operator=(long long v) {
        sign = 1;
        if (v < 0)
            sign = -1, v = -v;
        for (; v > 0; v = v / base)
            a.push_back(v % base);
    }

    bigint operator+(const bigint &v) const {
        if (sign == v.sign) {
            bigint res = v;

            for (int i = 0, carry = 0; i < (int) max(a.size(), v.a.size()) || carry; ++i) {
                if (i == (int) res.a.size())
                    res.a.push_back(0);
                res.a[i] += carry + (i < (int) a.size() ? a[i] : 0);
                carry = res.a[i] >= base;
                if (carry)
                    res.a[i] -= base;
            }
            return res;
        }
        return *this - (-v);
    }

    bigint operator-(const bigint &v) const {
        if (sign == v.sign) {
            if (abs() >= v.abs()) {
                bigint res = *this;
                for (int i = 0, carry = 0; i < (int) v.a.size() || carry; ++i) {
                    res.a[i] -= carry + (i < (int) v.a.size() ? v.a[i] : 0);
                    carry = res.a[i] < 0;
                    if (carry)
                        res.a[i] += base;
                }
                res.trim();
                return res;
            }
            return -(v - *this);
        }
        return *this + (-v);
    }

    void operator*=(int v) {
        if (v < 0)
            sign = -sign, v = -v;
        for (int i = 0, carry = 0; i < (int) a.size() || carry; ++i) {
            if (i == (int) a.size())
                a.push_back(0);
            long long cur = a[i] * (long long) v + carry;
            carry = (int) (cur / base);
            a[i] = (int) (cur % base);
            //asm("divl %%ecx" : "=a"(carry), "=d"(a[i]) : "A"(cur), "c"(base));
        }
        trim();
    }

    bigint operator*(int v) const {
        bigint res = *this;
        res *= v;
        return res;
    }

    friend std::pair<bigint, bigint> divmod(const bigint &a1, const bigint &b1) {
        int norm = base / (b1.a.back() + 1);
        bigint a = a1.abs() * norm;
        bigint b = b1.abs() * norm;
        bigint q, r;
        q.a.resize(a.a.size());

        for (int i = a.a.size() - 1; i >= 0; i--) {
            r *= base;
            r += a.a[i];
            int s1 = r.a.size() <= b.a.size() ? 0 : r.a[b.a.size()];
            int s2 = r.a.size() <= b.a.size() - 1 ? 0 : r.a[b.a.size() - 1];
            int d = ((long long) base * s1 + s2) / b.a.back();
            r -= b * d;
            while (r < 0)
                r += b, --d;
            q.a[i] = d;
        }

        q.sign = a1.sign * b1.sign;
        r.sign = a1.sign;
        q.trim();
        r.trim();
        return make_pair(q, r / norm);
    }

    bigint operator/(const bigint &v) const {
        return divmod(*this, v).first;
    }

    bigint operator%(const bigint &v) const {
        return divmod(*this, v).second;
    }

    void operator/=(int v) {
        if (v < 0)
            sign = -sign, v = -v;
        for (int i = (int) a.size() - 1, rem = 0; i >= 0; --i) {
            long long cur = a[i] + rem * (long long) base;
            a[i] = (int) (cur / v);
            rem = (int) (cur % v);
        }
        trim();
    }

    bigint operator/(int v) const {
        bigint res = *this;
        res /= v;
        return res;
    }

    int operator%(int v) const {
        if (v < 0)
            v = -v;
        int m = 0;
        for (int i = a.size() - 1; i >= 0; --i)
            m = (a[i] + m * (long long) base) % v;
        return m * sign;
    }

    void operator+=(const bigint &v) {
        *this = *this + v;
    }
    void operator-=(const bigint &v) {
        *this = *this - v;
    }
    void operator*=(const bigint &v) {
        *this = *this * v;
    }
    void operator/=(const bigint &v) {
        *this = *this / v;
    }

    bool operator<(const bigint &v) const {
        if (sign != v.sign)
            return sign < v.sign;
        if (a.size() != v.a.size())
            return a.size() * sign < v.a.size() * v.sign;
        for (int i = a.size() - 1; i >= 0; i--)
            if (a[i] != v.a[i])
                return a[i] * sign < v.a[i] * sign;
        return false;
    }

    bool operator>(const bigint &v) const {
        return v < *this;
    }
    bool operator<=(const bigint &v) const {
        return !(v < *this);
    }
    bool operator>=(const bigint &v) const {
        return !(*this < v);
    }
    bool operator==(const bigint &v) const {
        return !(*this < v) && !(v < *this);
    }
    bool operator!=(const bigint &v) const {
        return *this < v || v < *this;
    }

    void trim() {
        while (!a.empty() && !a.back())
            a.pop_back();
        if (a.empty())
            sign = 1;
    }

    bool isZero() const {
        return a.empty() || (a.size() == 1 && !a[0]);
    }

    bigint operator-() const {
        bigint res = *this;
        res.sign = -sign;
        return res;
    }

    bigint abs() const {
        bigint res = *this;
        res.sign *= res.sign;
        return res;
    }

    long long longValue() const {
        long long res = 0;
        for (int i = a.size() - 1; i >= 0; i--)
            res = res * base + a[i];
        return res * sign;
    }

    friend bigint gcd(const bigint &a, const bigint &b) {
        return b.isZero() ? a : gcd(b, a % b);
    }
    friend bigint lcm(const bigint &a, const bigint &b) {
        return a / gcd(a, b) * b;
    }

    void read(const string &s) {
        sign = 1;
        a.clear();
        int pos = 0;
        while (pos < (int) s.size() && (s[pos] == '-' || s[pos] == '+')) {
            if (s[pos] == '-')
                sign = -sign;
            ++pos;
        }
        for (int i = s.size() - 1; i >= pos; i -= base_digits) {
            int x = 0;
            for (int j = max(pos, i - base_digits + 1); j <= i; j++)
                x = x * 10 + s[j] - '0';
            a.push_back(x);
        }
        trim();
    }

    friend istream& operator>>(istream &stream, bigint &v) {
        string s;
        stream >> s;
        v.read(s);
        return stream;
    }

    friend ostream& operator<<(ostream &stream, const bigint &v) {
        if (v.sign == -1)
            stream << '-';
        stream << (v.a.empty() ? 0 : v.a.back());
        for (int i = (int) v.a.size() - 2; i >= 0; --i)
            stream << setw(base_digits) << setfill('0') << v.a[i];
        return stream;
    }

    static vector<int> convert_base(const vector<int> &a, int old_digits, int new_digits)
    {
        vector<long long> p(max(old_digits, new_digits) + 1);
        p[0] = 1;
        for (int i = 1; i < (int) p.size(); i++)
            p[i] = p[i - 1] * 10;
        vector<int> res;
        long long cur = 0;
        int cur_digits = 0;
        for (int i = 0; i < (int) a.size(); i++) {
            cur += a[i] * p[cur_digits];
            cur_digits += old_digits;
            while (cur_digits >= new_digits) {
                res.push_back(int(cur % p[new_digits]));
                cur /= p[new_digits];
                cur_digits -= new_digits;
            }
        }
        res.push_back((int) cur);
        while (!res.empty() && !res.back())
            res.pop_back();
        return res;
    }

    typedef vector<long long> vll;

    static vll karatsubaMultiply(const vll &a, const vll &b)
    {
        int n = a.size();
        vll res(n + n);
        if (n <= 32) {
            for (int i = 0; i < n; i++)
                for (int j = 0; j < n; j++)
                    res[i + j] += a[i] * b[j];
            return res;
        }

        int k = n >> 1;
        vll a1(a.begin(), a.begin() + k);
        vll a2(a.begin() + k, a.end());
        vll b1(b.begin(), b.begin() + k);
        vll b2(b.begin() + k, b.end());

        vll a1b1 = karatsubaMultiply(a1, b1);
        vll a2b2 = karatsubaMultiply(a2, b2);

        for (int i = 0; i < k; i++)
            a2[i] += a1[i];
        for (int i = 0; i < k; i++)
            b2[i] += b1[i];

        vll r = karatsubaMultiply(a2, b2);
        for (int i = 0; i < (int) a1b1.size(); i++)
            r[i] -= a1b1[i];
        for (int i = 0; i < (int) a2b2.size(); i++)
            r[i] -= a2b2[i];

        for (int i = 0; i < (int) r.size(); i++)
            res[i + k] += r[i];
        for (int i = 0; i < (int) a1b1.size(); i++)
            res[i] += a1b1[i];
        for (int i = 0; i < (int) a2b2.size(); i++)
            res[i + n] += a2b2[i];
        return res;
    }

    bigint operator*(const bigint &v) const {
        vector<int> a6 = convert_base(this->a, base_digits, 6);
        vector<int> b6 = convert_base(v.a, base_digits, 6);
        vll a(a6.begin(), a6.end());
        vll b(b6.begin(), b6.end());
        while (a.size() < b.size())
            a.push_back(0);
        while (b.size() < a.size())
            b.push_back(0);
        while (a.size() & (a.size() - 1))
            a.push_back(0), b.push_back(0);
        vll c = karatsubaMultiply(a, b);
        bigint res;
        res.sign = sign * v.sign;
        for (int i = 0, carry = 0; i < (int) c.size(); i++) {
            long long cur = c[i] + carry;
            res.a.push_back((int) (cur % 1000000));
            carry = (int) (cur / 1000000);
        }
        res.a = convert_base(res.a, 6, base_digits);
        res.trim();
        return res;
    }
};
inline bigint pow(bigint a,int n)
{
    bigint res=1;
    while(n)
        if(n&1)
            res=res*a,--n;
        else
            a*=a,n/=2;
    return res;
}

bigint t, w, b;

//bigint gcd(bigint a, bigint b){
//  while(b!=bigint(0)){
//      a%=b;
//      swap(a, b);
//  }
//  return a;
//}

void solve(){
    cin>>t>>w>>b;
    bigint nok=(w/gcd(w, b))*b;
    bigint n=t/nok;
    bigint k;
    if(n!=bigint(0)) k=min(w, b)-1+(n-1)*(min(w, b))+min(min(w, b), t%nok+1);
    else k=min(w, b)-1;
    bigint g=gcd(t, k);
    t/=g;
    k/=g;
    if(k>=t) k=bigint(1), t=bigint(1);
    cout<<k<<"/"<<t;
}

int main(){
//  freopen("INPUT.TXT", "r", stdin);   freopen("OUTPUT.TXT", "w", stdout);
    solve();
}
/*

*/

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#define MAXN 101000
#define LL long long
#define Ri(a) scanf("%d", &a)
#define Pi(a) printf("%d\n", (a))
#define Rl(a) scanf("%lld", &a)
#define Pl(a) printf("%lld\n", (a))
#define Rs(a) scanf("%s", a)
#define Ps(a) printf("%s\n", (a))
#define W(a) while(a--)
#define CLR(a, b) memset(a, (b), sizeof(a))
#define INF 0x3f3f3f3f
using namespace std;
LL gcd(LL a, LL b){
    return b == 0 ? a : gcd(b, a%b);
}
int main()
{
    LL t, w, b;
    Rl(t), Rl(w), Rl(b);
    LL GCD = gcd(w, b);
    LL ans;
    if(w * 1.0 / GCD * b > (double)t)
        ans = min(t, min(w-1, b-1));
    else
    {
        LL LCM = w / GCD * b;
        LL num = t / LCM;
        LL remain = t - num * LCM;
        ans = num * min(w, b) + min(remain, min(w-1, b-1));
    }
    GCD = gcd(ans, t);
    printf("%lld/%lld\n", ans/GCD, t/GCD);
    return 0;
}

//Bismillahir Rahmanir Rahim
#include<cstdio>
#include<cstring>
#include<cmath>
#include<cctype>
#include<cassert>
#include<cstdlib>
#include<iostream>
#include<iomanip>
#include<string>
#include<sstream>
#include<algorithm>
#include<vector>
#include<stack>
#include<list>
#include<queue>
#include<set>
#include<map>
#include<utility>
#include<bitset>
#include<ctime>
using namespace std;

#define i64 long long int
#define u64 unsigned long long int

#define fin(a) freopen(a,"r",stdin)
#define fout(a) freopen(a,"w",stdout)

#define repc(i,a,b) for(__typeof(b) i=(a); i<=(b); i++)
#define repr(i,a,b) for(__typeof(b) i=(a); i>=(b); i--)

#define clr(a) a.clear()
#define sz(a) (int)a.size()
#define mem(a,b) memset(a,b,sizeof a)
#define ERASE(a) a.erase(a.begin(),a.end())

#define sc scanf
#define S(z) scanf("%d",&z)
#define SL(z) scanf("%I64d",&z)
#define S2(xx,zz) scanf("%d %d",&xx,&zz)
#define SL2(xx,zz) scanf("%I64d %I64d",&xx,&zz)
#define SC(z) scanf("%s",&z)

#define pf printf
#define pfn printf("\n")
#define PF(z) printf("%d",z)
#define PFL(z) printf("%I64d",z)
#define PF2(x,y) printf("%d %d",x,y)
#define PFL(z) printf("%I64d",z)
#define PFS(z) printf("%s",z)

#define ff first
#define ss second
#define mp make_pair

#define MI map<int,int>
#define MSI map<string,int>
#define MIS map<int,string>
#define SI set<int>
#define SS set<string>
#define SMI multiset<int>
#define VI vector<int>
#define VI2 vector < vector < int > >
#define QU queue<int>
#define PQU priority_queue<int>
#define STK stack<int>
#define pb push_back

#define inf 100000007LL
#define pi  acos(-1.0)
#define MAX 200007
#define MOD 1000000007
#define eps 1e-9

template <class T>T sqr(T x) {return x*x;}
template< class T > T gcd(T a, T b) { return (b != 0 ? gcd<T>(b, a%b) : a); }
template< class T > T lcm(T a, T b) { return (a / gcd<T>(a, b) * b); }
template <class T> inline T bigmod(T p,T e,T M)
{
    if(e==0) return 1;
    if(e%2==0){i64 t=bigmod(p,e/2,M);return (T)((t*t)%M);}
    return (T)((i64)bigmod(p,e-1,M)*(i64)p)%M;
}
template <class T> inline T bigexp(T p,T e)
{
    if(e==0)return 1;
    if(e%2==0){i64 t=bigexp(p,e/2);return (T)((t*t));}
    return (T)((i64)bigexp(p,e-1)*(i64)p);
}
template <class T> inline T modinverse(T a,T M){return bigmod(a,M-2,M);}

int dx4[]={1,0,-1,0};int dy4[]={0,1,0,-1}; //4 Direction
int dx8[]={1,1,0,-1,-1,-1,0,1};int dy8[]={0,1,1,1,0,-1,-1,-1};//8 direction
int month[]={31,28,31,30,31,30,31,31,30,31,30,31};
/*
struct Graph
{
    int u,v,w;
    bool operator<(const Graph& p)
    const {return w<p.w;} // oporerta chotor jnne
}edge[10];
struct compare
{
    bool operator()(const int&l,const int&r)
    {
        return l>r;
    }
};
priority_queue<int,vector<int>,compare>pq;
*/
/******************* Code Starts here *******************/

i64 t,a,b,c,d,res,p;

int main()
{
    sc("%I64d %I64d %I64d",&t,&a,&b);
    if(a>b) swap(a,b);
    c=a;
    i64 g=gcd(a,b);
    double l=(double)(a/g)*b;
    if(t<b || l>t)
    {
        res+=c-1;
       if(t<a) res=t;
       else if(t<b) res=c-1;
       else if(a==b || g==b ) res=c;
    }
    else
    {
    c--;
    res+=c;
       d=t/l;
       p=t-(l*d);
           res+=d;
           if(d>0) d--;
           d*=c;
           res+=d;
       c=min(c,p);
       res+=c;
    }
    g=gcd(res,t);
    pf("%I64d/%I64d",res/g,t/g);
    return 0;
}

#include <bits/stdc++.h>

using namespace std;

int main() {
  long long t, w, b;
  scanf("%I64d %I64d %I64d", &t, &w, &b);
  if (w / __gcd(w, b) > t / b) {
    long long up = min(t, min(w, b) - 1);
    long long a = __gcd(up, t);
    printf("%I64d/%I64d", up / a, t / a);
    return 0;
  }
  long long a = (long long) ((double) min(w, b) / __gcd(w, b) * max(w, b));
  long long mn = min(w, b);
  long long ans = t / a * mn - 1 + min(t % a + 1, mn);
  long long k = __gcd(ans, t);
  printf("%I64d/%I64d", ans / k, t / k);
}

#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll gcd(ll a,ll b){
    if(b==0)
    return a;
    else
    return gcd(b,a%b);
}
int main(){
    ll t,w,b,res=0;
    cin>>t>>w>>b;
    if(b>w){
        ll temp=b;
        b=w;
        w=temp;
    }
    if(t<b){
        cout<<"1/1";
        exit(0);
    }
    res+=b-1;
    ll g=gcd(w,b);
    ll gum=((t*1.0)/(w/g))/b;
    if(gum>0)
    res+=(gum-1)*b;
    ll dum=t-(gum*w)*(b/g)+1;
    if(gum>0)
    res+=min(dum,b);
    g=gcd(t,res);
    t/=g;
    res/=g;
    cout<<res<<"/"<<t;
}

#include <bits/stdc++.h>

using namespace std;

#define sz(a) (int)a.size()
#define ll long long
#define INF 0x3f3f3f3f
// LLONG_MIN LLONG_MAX INT_MIN INT_MAX

ll gcd (ll a, ll b)
{
    while(b!=0)
    {
        ll c=a%b;
        a=b;
        b=c;
    }
    return a;
}

int main(){
    ll t,w,b;
    scanf("%lld %lld %lld",&t,&w,&b);

    ll tie=w/gcd(w,b)*b;
    ll more=min(w,b)-1;
    ll cnt=0;

    if(LLONG_MAX/(w/gcd(w,b))<b || tie>t)
        cnt+=min(t,min(w,b)-1);
    else
    {
        cnt+=t/tie+(t/tie)*more;
        cnt+=min(t%tie,more);
    }
    ll d=gcd(cnt,t);
    cnt/=d;
    t/=d;
    printf("%lld/%lld\n",cnt,t);
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

const ll INF = 6e18;

int main() {
    ll t, w, b;
    cin >> t >> w >> b;
    ll good = 0;
    if(w == b){
        cout << "1/1\n";
        return 0;
    }
    ll g = __gcd(w, b);
    if(w/g > INF/b)
        good = min(t + 1, min(w, b)) - 1;
    else {
        ll pd = w/g * b;
        ll cy = (t + 1)/pd;
        ll k = (t + 1)% pd;
        good = min(w, b) * cy + min(k, min(w, b));
        good--;
    }
    g = __gcd(good, t);
    cout << good/g << "/" << t/g << '\n';
}

#include <bits/stdc++.h>

#define SZ(x) (((int)x.size()))

typedef unsigned long long ull;

using namespace std;

ull t, b, w, g, kmm, p, q, tmp;

int main()
{
    cin >> t >> w >> b;
    g = gcd(w, b);
	if (w / g <= t / b)
	{
		kmm = lcm(w, b);
		tmp = t / kmm;
		p = (tmp + 1) * min(w, b) - 1;
		tmp *= kmm;
	}
	else
		p = min(w, b) - 1;
	if (tmp + min(w, b) - 1 > t)
		p -= tmp + min(w, b) - 1 - t;
	q = t;
	g = gcd(p, q);
	cout << p / g << '/' << q / g;
	return 0;
}

//#include <vector>
//#include <list>
//#include <map>
//#include <math.h>
//#include <cmath>
//#include <set>
//#include <queue>
//#include <deque>
//#include <string>
//#include <stack>
//#include <bitset>
//#include <algorithm>
//#include <functional>
//#include <numeric>
//#include <utility>
//#include <string.h>
//#include <sstream>
//#include <iostream>
//#include <iomanip>
//#include <cstdio>
//#include <cstdlib>
//#include <ctime>
//
//#define ll long long int
//#define ld long double
//using namespace std;
//long long gcd(long long a, long long b)
//{
//	if (a < b)
//		swap(a, b);
//	if (b == 0)
//		return a;
//	return gcd(b, a%b);
//}
//int main()
//{
//	ios::sync_with_stdio(false);
//	ios_base::sync_with_stdio(false);
//	cin.tie(nullptr), cout.tie(nullptr);
//	//freopen("output.txt", "w", stdout);
//	//freopen("input.txt", "r", stdin);
//	long long l, a, b;
//	while (cin >> l >> a >> b)
//	{
//		long long c = l / (a / gcd(a, b)) / b;
//		if (c == 0)
//		{
//			long long ans = min(l, min(a, b) - 1);
//			cout << ans / gcd(ans, l) << "/" << l / gcd(ans, l) << endl;
//			continue;
//		}
//		long long lcm = a / gcd(a, b)*b;
//		long long ans = (l / lcm)*(min(a, b)) + min(l%lcm, min(a, b) - 1);
//		cout << ans / gcd(ans, l) << "/" << l / gcd(ans, l) << endl;
//	}
//}

//#include <vector>
//#include <list>
//#include <map>
//#include <math.h>
//#include <cmath>
//#include <set>
//#include <queue>
//#include <deque>
//#include <string>
//#include <stack>
//#include <bitset>
//#include <algorithm>
//#include <functional>
//#include <numeric>
//#include <utility>
//#include <string.h>
//#include <sstream>
//#include <iostream>
//#include <iomanip>
//#include <cstdio>
//#include <cstdlib>
//#include <ctime>
//
//using namespace std;
//typedef unsigned long long ull;
//ull t, w, b;
//ull gcd(ull a, ull b)
//{
//	if (b == 0) return a;
//	return gcd(b, a%b);
//}
//
//ull lcm(ull a, ull b)
//{
//	if (t / b + 1 < a / gcd(a, b)) return t + 1;
//	return (a / gcd(a, b)) * b;
//}
//
//int main()
//{
//	cin >> t >> w >> b;
//	ull mn = min(w, b);
//	ull nm = t / lcm(w, b);
//	ull num;
//	if (nm == 0)
//	{
//		num = min(mn - 1, t);
//	}
//	else
//	{
//		num = nm*mn + min(mn - 1, t%lcm(w, b));
//	}
//	ull g = gcd(num, t);
//	cout << num / g << "/" << t / g << endl;
//	return 0;
//}

#include <vector>
#include <list>
#include <map>
#include <math.h>
#include <cmath>
#include <set>
#include <queue>
#include <deque>
#include <string>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <string.h>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <ctime>

#define ll long long int
#define ull  long long int
#define ld long double
using namespace std;
ull GCD(ull a, ull b)
{
	if (b < a)
		swap(a, b);
	if (a == 0)
		return b;
	return GCD(a, b%a);
}
ull LCM(ull a, ull b)
{
	ull ret = GCD(a, b);
	ret = a / ret;
	ret *= b;
	return ret;
}
int main()
{
	ios::sync_with_stdio(false);
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr), cout.tie(nullptr);
	//freopen("output.txt", "w", stdout);
	//freopen("input.txt", "r", stdin);
	ull l, b, a, answer;
	cin >> l >> a >> b;
	ull lcm = LCM(a, b);
	ull gogo = l / a*GCD(a, b) / b;
	if (!gogo)
		answer = min(l, min(a, b) - 1);
	else
		answer = (l / lcm)*min(a, b)+ min(min(a-1,b-1), l%lcm);
	ull g = GCD(l, answer);
	cout <<answer/g<<"/"<<l/g<< endl;
	return 0;
}

#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ll;

#define debug1(x)		  cout<<x<<endl
#define debug2(x,y)       cout<<x<<"   "<<y<<endl
#define debug3(x,y,z)     cout<<x<<"   "<<y<<"   "<<z<<endl
#define debug4(x,y,z,xy)  cout<<x<<"   "<<y<<"   "<<z<<"   "<<xy<<endl

#define sl(x) scanf("%lld",&x)
#define sll(x,y) scanf("%lld%lld",&x,&y)
#define slll(x,y,z) scanf("%lld%lld%lld",&x,&y,&z)
#define pl(x) printf("%lld\n",x)
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
#define ff first
#define ss second
#define MAX 1000001
#define mod 1000000007

int main(){
     ll n,i,a,b;
     cin>>n>>a>>b;
     ll g=__gcd(a,b);
     ll mi=min(a,b)-1;
     if(n<=mi){
          cout<<"1/1";
          return 0;
     }

     if(a/g>n/b){
          ll num=mi;
          g=__gcd(num,n);
          num=num/g;
          n=n/g;
          cout<<num<<"/"<<n;
          return 0;
     }

     ll lcm=(a/g)*b;;
     ll x=n/lcm;
     ll y=x*lcm;
     ll num=min(mi+1,n-y+1)+mi;
     num+=(x-1)*min(a,b);
//     cout<<num<<endl;

     g=__gcd(num,n);
     num=num/g;
     n=n/g;
     cout<<num<<"/"<<n;
}
//683705963104411677 89876390 116741460012229240

#include <stdio.h>
#include <string.h>
#include <algorithm>

using namespace std;

typedef long long ll;

ll GCD(ll A,ll B)
{
    if (!B)
       return A;

    return GCD(B,A % B);
}

int main()
{
    #ifndef ONLINE_JUDGE
        freopen("a.in","r",stdin);
        freopen("a.out","w",stdout);
    #endif

    ll T,W,B;

    scanf("%I64d %I64d %I64d",&T,&W,&B);

    if (W > B)
       swap(W,B);

    ll D = GCD(W,B),
       X = B / D,
       Y = T / W,
       Sol = (Y / X + 1) * W - 1;

    if (Y % X == 0)
    {
        ll aux = (Y + 1) * W - 1;

        if (T <= aux)
           Sol -= (aux - T);
    }

    D = GCD(Sol,T);

    printf("%I64d/%I64d\n",Sol / D,T / D);

  return 0;
}

#include<bits/stdc++.h>
#define int long long
using namespace std;
main()
{
    int t,w,b;
    int s;
    cin >> t >> w >> b;
    int kuk = w / __gcd(w,b) * b,x;
    if(t/b >= w/__gcd(w,b))
        x = t % kuk,s = t/kuk;
    else
        x = t,s = 0;
    int a = s * min(w,b);
    a += min(x,min(w,b) - 1);
    int d = __gcd(a,t);
    cout << a/d << "/" << t/d;
}

#include <stdio.h>
#include <string.h>
#include <algorithm>

using namespace std;

typedef long long ll;

ll A,B,C,Sol;

ll GCD(ll A,ll B)
{
    if (!B)
       return A;

    return GCD(B,A % B);
}

int main()
{
    #ifndef ONLINE_JUDGE
        freopen("a.in","r",stdin);
        freopen("a.out","w",stdout);
    #endif

    scanf("%I64d %I64d %I64d",&C,&A,&B);

    if (A > B)
       swap(A,B);

    ll D = GCD(A,B),M = A * (B / D);

    Sol = A - 1;

    ll aux = C / M;

    Sol += aux * A;

    D = GCD(Sol,C);

    Sol /= D;
    C /= D;

    printf("%I64d/%I64d\n",Sol,C);

  return 0;
}

#include <iostream>
#include <iomanip>
#include <math.h>
#include <algorithm>
#include <stdio.h>
#include <vector>
#include <utility>
#include <set>
#include <queue>
#include <string>
#define pb push_back
#define mp make_pair
#define f first
#define s seconddf

using namespace std;
const long long INF = 5000000000000000000LL;
long long nod(long long a, long long b){
	if(a%b!=0)
		return nod(b,a%b);
	else return b;
};

int main(){
	long long n, i, j, t, w, b, sum = 0LL;
	long long nok = -1LL, nod1;
	cin >> t >> w >> b;
	if(min(w,b) < t)
		sum = min(w,b) - 1;
	else
		sum = t;
	nod1 = nod(w,b);
	if((INF / w > b && INF  / b > w) && (w * b > 0)){   //(!(w * b > INF || w*b < 0))
		nok = w * b / nod1;
		sum = sum + (t / nok) * min(w,b);
	}
	if(t % nok < min(w,b) && nok != -1 && nok <= t)
		sum = sum  - min(w,b) + t % nok + 1;
	long long nod2;
	nod2 = nod(sum, t);
	sum = sum / nod2;
	t = t / nod2;
	cout <<sum << "/" << t;
return 0;}

/*

*/

#include<iostream>
#include<fstream>
#include<cmath>
#include<algorithm>
#define inf=10000000000000000001
#define pb=push_back
using namespace std;
//ifstream f("date.in");
unsigned long long t,w,b,rez,c,mare,mic,i,cmmmc,rezp;
bool verificare(unsigned long long a, unsigned long long b,unsigned long long p){
    long long pz1=0,pz2=0;
    while(a){
        pz1++;
        a/=10;
    }
    while(b){
        pz1++;
        b/=10;
    }
    while(p){
        pz2++;
        p/=10;
    }
    return pz1<pz2;
}
unsigned long long euclid(unsigned long long a,unsigned long long b){
    unsigned long long r;
    while(b!=0){
        r=a%b;
        a=b;
        b=r;
    }
    return a;
}
int main(){
    cin>>t>>w>>b;
    if(w!=b){
        mare=max(w,b);
        mic=min(w,b);
        rez+=min(t,mic)-1;
        cmmmc=euclid(mic,mare);
        if(verificare(mic,mare,t)){
            cmmmc=t/(cmmmc*(mic/cmmmc)*(mare/cmmmc));
            rezp=cmmmc*(rez+1);
            if(mare%mic||t%mare)
                rezp+=rez;
        }else rezp+=rez;
        c=euclid(rezp,t);
        rezp/=c;
        t/=c;
        cout<<rezp<<'/'<<t;

    }else cout<<"1/1";
    return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#include <functional>
#include <map>
#include <assert.h>
#define SI(i) scanf("%d", &i)
#define SII(i,j) scanf("%d%d", &i, &j)
#define SIII(i,j, k) scanf("%d%d%d", &i, &j, &k)
#define SL(i) scanf("%I64d", &i)
#define SLL(i,j) scanf("%I64d%I64d", &i, &j)
#define SLLL(i,j, k) scanf("%I64d%I64d%I64d", &i, &j, &k)
#define SS(i) scanf("%s\n", i)
#define SSS(i,j) scanf("%s %s", i, j)
#define SC(i) scanf("%d", &i)
#define SCC(i,j) scanf("%c %c\n", &i, &j)

#define PI(i) printf("%d ", i)
#define PII(i,j) printf("%d %d ", i, j)
#define PL(i) printf("%I64d ", i)
#define PLL(i,j) printf("%I64d %I64d ", i, j)
#define PS(i) printf("%s", i)
#define PSS(i,j) printf("%s %s ", i, j)
#define PC(i) printf("%c", i)
#define PCC(i,j) printf("%c %c ", i, j)
#define PN printf("\n")
#define forin(i, k, n) for(int i = (k); i < (n); ++i)
#define rforin(i, k, n) for(int i = (k); i > (n); --i)
#define my_mod 1000000007
using namespace std;
unsigned long long t, w, b, ans = 0, com = 0, tmp = 0, lccm = 0;
long long gcd(long long aa, long long bb)
{
	long long tmp;
	while (aa > 0)
	{
		tmp = aa;
		aa = bb%aa;
		bb = tmp;
	}
	return bb;
}
long long lcm(long long aa, long long bb)
{
	return aa * bb / gcd(aa, bb);
}
int main()
{
#ifdef _DEBUG
	freopen("1.in", "rt", stdin);
	freopen("1.out", "wt", stdout);
#endif
	SLLL(t, w, b);
	if (w > b)
		swap(w, b);
	com = 1;
	tmp = w;
	if (w > 1)
		ans = w - 1;
	lccm = lcm(w, b);
	if (t >= lccm)
	{
		com = t / lccm;
		ans += com;
		ans += com*(w - 1);
		tmp = com*lccm + (w - 1);
	}
	if (t < tmp)
		ans -= (tmp - t);
	tmp = gcd(ans, t);

	cout << ans / tmp << "/" << t / tmp;
	return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <math.h>
#include <algorithm>
#include <stdio.h>
#include <iomanip>
#include <set>
#include <list>
#include <map>
#include <stack>
#include <queue>
#include <exception>
#include <typeinfo>
using namespace std;

long long gcd ( long long a, long long b )
{
  long long c;
  while ( a != 0 ) {
     c = a; a = b%a;  b = c;
  }
  return b;
}

int main()
{
    ios_base::sync_with_stdio(false);
    long long t, b, w;
    unsigned long long p = 0, q = 0;
    cin>>t>>b>>w;
    if (t < b && t < w || b == w) cout<<"1/1\n";
    else if (t < b || t < w) cout<<"0/1\n";
    else
    {
        long long a = gcd(b, w);
        q = t;
        if (t / w < b / a)
        {
            p = min(w, b) - 1;
        }
        else
        {
            long long l = (b / a) * w;
            long long m = t % l;
            p = ((t)/l+1)*min(w,b)-1;
            if (m < min(w,b))
            {
                p -= min(w,b) - m;
            }
        }
        a = gcd(p, q);
        p = p/a;
        q = q/a;
        cout<<p<<'/'<<q<<endl;
    }
    return 0;
}

#include<iostream>
#include<cmath>
using namespace std;
long long oo;
long long gcd(long long a,long long b)
{
    long long t;
    if(a<b)
    {
        t=a;
        a=b;
        b=t;
    }
    while(t=a%b)
    {
        a=b;
        b=t;
    }
    return b;
}
long long zd(long long a,long long b)
{
	for(int i=1;i<=oo;i++)
	{
		long long mm=i*b;
		if(mm%a==0)
		{
			return mm;
		}
	}
	return 0;
}
int main()
{
	long long t,w,b;
	cin>>t>>w>>b;
	long long y=min(w,b),yy=max(w,b);
	if(y>t)
	{
		cout<<"1/1"<<endl;
		return 0;
	}
	if(yy>t)
	{
		if(y-1==0)
		{
			cout<<"0"<<endl;
			return 0;
		}
		long long zz=gcd(y-1,t);
		cout<<(y-1)/zz<<"/"<<t/zz<<endl;
		return 0;
	}
	oo=t/y;
	long long x=zd(y,yy);
	if(x==0)
	{
		if(y-1==0)
		{
			cout<<"0"<<endl;
			return 0;
		}
		long long e=y-1,r=t;
		long long z=gcd(e,r);
		cout<<e/z<<"/"<<r/z<<endl;
	}
	else
	{
		long long k=t/x;
		long long kk=min(t-k*x,y-1);
		kk=k+(k-1)*(y-1)+kk+(y-1);
		long long z=gcd(kk,t);
		cout<<kk/z<<"/"<<t/z<<endl;
	}
}

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <set>
#include <queue>
#include <stack>
#include <deque>
#include <map>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <algorithm>
#define pb push_back
#define fname ""
#define ll long long
#define s second
#define f first
#define mp make_pair

using namespace std;

ll w, b, t, gcd, lcm, tmp, cur, ans;

int main() {
    #ifndef ONLINE_JUDGE
    freopen(fname"in", "r", stdin);
    freopen(fname"out", "w", stdout);
    #endif
    cin >> t >> w >> b;
    if (w > b) swap(w, b);
    gcd = __gcd(w, b);
//  lcm = b/gcd*w;
    cur = t/w/b*gcd;
//  cout << lcm << endl;
    ans += cur;
    if (w > t) {
        cout << 1 << '/' << 1 << endl;
        return 0;
    }
    ans += cur*(w-1);
    tmp = t - cur*lcm;
    ans += min(w-1, tmp);

//  cout << ans << endl;
    tmp = __gcd(ans, t);
    ans /= tmp;
    t /= tmp;
    cout << ans << '/' << t << endl;
    return 0;
}

#include<iostream>
#include<vector>
#include<math.h>
#include<string>
#include<map>
#include<algorithm>
#include<queue>
using namespace std;
typedef unsigned long long ll;
ll gcd (ll a,ll b)
{
	if (b==0) return a;
	else return gcd(b,a%b);
}
ll lcm (ll a,ll b,ll t)
{
	ll x = a / gcd(max(a,b),min(a,b));
	//cout<<x<<endl;
	ll y = t/x;
	if (y < b) return 0;
	else return x*b;
}
ll min1 (ll a,ll b) {if (a<b) return a;else return b;}
//ll euler (ll n,ll mul)
//{
//	ll s = sqrt((double)n);
//	ll ans = 1;
//
//	return n - ans;
//}
int main ()
{
	//freopen("input.txt","r",stdin);
	//freopen("output.txt","w",stdout);
	unsigned long long t,w,b;
	cin>>t>>w>>b;
	if (w==b) {cout<<1<<"/"<<1;return 0;}
	ll c = lcm(w,b,t);
	//cout<<c<<endl;
	if (c!=0)
	{
		ll k = (ll)(t / c);
		//cout<<k<<endl;
		ll ans = ((min1(w,b) * (k)) + ((/*gcd(max(w,b),min(w,b))!=1 || */min1(w,b)==1)?0:min1(w,b) - 1)) - (gcd(max(w,b),min(w,b))!=1)?(min1(w,b) - 1):0;
		//cout<<ans<<" "<<gcd(ans,t)<<endl;
		cout<<(ll)(ans/(ll)gcd(t,ans))<<"/"<<(ll)(t/(ll)(gcd(t,ans)));
	}
	else {
		//ll g = (min1(w,b) - 1);
		ll g = (gcd(max(w,b),min(w,b))!=1)?0:min1(w,b) - 1;
		ll gc = gcd(t,g);
		cout<<g/gc<<"/"<<t/gc;
	}
	//system("pause");
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;

#define pb push_back
#define mp make_pair

ull gcd(ull a, ull b){
    if(b == 0) return a;
    return gcd(b, a % b);
}

int main()
{
    ios_base::sync_with_stdio(0);
    long double t, w, b;
    cin >> t >> w >> b;
    long double g = gcd(w, b);
    long double lcm = w * b / g;
    ull ans = (ull(t / lcm) + 1) * ull(min(w, b)) - 1;
    ull gc = gcd(ans, t);
    ull q = t;
    ans /= gc;
    q /= gc;
    cout << ans << '/' << q << endl;
    return 0;
}

        #include <bits/stdc++.h>
        using namespace std;

        int main() {

                      long long int a,b,c;
                      cin >> a >> b >> c;

                      long long int x=__gcd(b,c);
                      long long int lcm= (b/x)*c;
                      long long int ans=0;
                      if(b/x==lcm/c)
                      {

                       ans = (a/lcm)*(min(b,c));

                      }
                      ans+=(min(a%lcm, min(b,c)-1));
                      long long int p=__gcd(a,ans);

                      cout << ans/p <<"/"<<a/p;

        	// your code goes here
        	return 0;
        }

#include<bits/stdc++.h>
#define In_the_name_of_allah_the_merciful ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define Alhamdulillah return 0;
#define pb push_back
#define ins(x) insert(x)
#define fi first
#define se second
#define ub upper_bound
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define sz(v) ((ll)((v).size()))
#define reset(v,val) memset(v,val,sizeof(v))
#define loop(i, x, n) for ( i = x; i<=(ll)(n); i++)
#define loopinverse(i, n, x) for( i = n; i>=x; i--)
#define MAXN 300015
using namespace std;
typedef   long long int  ll;
typedef long double ld;
ll mod=1e9+7;
long double eps = 1e-12;
ll dx[]={0,0,1,-1,1,1,-1,-1};
ll dy[]={1,-1,0,0,1,-1,1,-1};
ll n,res=0,k=0,h,ans=0,m;
ll gcd(ll a, ll b){if (b == 0)return a;return gcd(b, a % b);}
ll lcm(ll x,ll y){x/=gcd(x,y);if(x>(5e18/y))return -1;return (x*y);}
ll pot(ll a, ll b){ll r = 1;while (b){if (b%2) r =(r*a)%mod;a = (a*a)%mod;b /= 2;}return r%mod;}
void pr(ll a[],ll n){for(ll i=1;i<=n;i++)cout<<a[i]<<" ";cout<<'\n';}
void read(ll a[],ll n){for(ll i=1;i<=n;i++)cin>>a[i];}
void yes(){cout<<"YES\n";}
void no(){cout<<"NO\n";}
vector< ll >v[MAXN];
void add_edge(ll x,ll y){v[x].pb(y);v[y].pb(x);}
string s2,ch="",s,s1="",t;
vector< pair<string,ll> >vs;
vector< pair< pair<ll,ll>,ll > > vvv,vvv2;
vector<pair<ll,ll> >vv[MAXN],vv2;
ll a[MAXN],b[MAXN];

int main(){
/******************************************/In_the_name_of_allah_the_merciful/****************************************************/

    ll i=0,x=0,z=0,y=0,j=0,q,mx=0,mm,idx=0,ok=0,l=0,r,negatif=0,positif=0;
    set< ll  > ::iterator itw,ith;
    set<ll>::iterator it;
    multiset<ll>mst,mst2;
    #ifndef ONLINE_JUDGE
        freopen("a.txt","r",stdin);
    #endif
    cin>>n>>x>>y;
    if(x==y)return cout<<"1/1",0;
    ll lc=lcm(x,y);
    m=min(x,y);
    if(lc==-1){
        res=(m-1);
        ll gc=gcd(n,res);
        res/=gc;
        n/=gc;
        cout<<res<<"/"<<n;
        return 0;
    }
   // cout<<lc<<endl;
    ll d=n/lc;
    ll md=n%lc;
    if(d)d--;
    res=d*m;
    md=min(md+1,m);
    if((n/lc)>0)  res+=md;
    if((m-1)<lc)res+=(m-1);
    ll gc=gcd(n,res);
    res/=gc;
    n/=gc;
    cout<<res<<"/"<<n;
/*****************************************************/Alhamdulillah/**************************************************************/
}

# include <functional>
# include <algorithm>
# include <iostream>
//# include <hash_set>
//# include <hash_map>
# include <string.h>
# include <iterator>
# include <assert.h>
# include <utility>
# include <cstring>
# include <sstream>
# include <iomanip>
# include <bitset>
# include <string>
# include <cstdio>
# include <vector>
# include <deque>
# include <queue>
# include <stack>
# include <cmath>
# include <ctime>
# include <list>
# include <map>
# include <set>
//#pragma comment (linker, "/STACK:17000000")

#define mp make_pair
#define pb push_back
#define all(v) v.begin(),v.end()

using namespace std;

typedef long long ll;
typedef pair<int, int > P;
typedef long double db;

const db eps=1e-9, pi=acos(-1.0);
const ll inf=2000000009;

const int base = 1000000000;
const int base_digits = 9;

struct bigint {
    vector<int> a;
    int sign;

    bigint() :
        sign(1) {
    }

    bigint(long long v) {
        *this = v;
    }

    bigint(const string &s) {
        read(s);
    }

    void operator=(const bigint &v) {
        sign = v.sign;
        a = v.a;
    }

    void operator=(long long v) {
        sign = 1;
        if (v < 0)
            sign = -1, v = -v;
        for (; v > 0; v = v / base)
            a.push_back(v % base);
    }

    bigint operator+(const bigint &v) const {
        if (sign == v.sign) {
            bigint res = v;

            for (int i = 0, carry = 0; i < (int) max(a.size(), v.a.size()) || carry; ++i) {
                if (i == (int) res.a.size())
                    res.a.push_back(0);
                res.a[i] += carry + (i < (int) a.size() ? a[i] : 0);
                carry = res.a[i] >= base;
                if (carry)
                    res.a[i] -= base;
            }
            return res;
        }
        return *this - (-v);
    }

    bigint operator-(const bigint &v) const {
        if (sign == v.sign) {
            if (abs() >= v.abs()) {
                bigint res = *this;
                for (int i = 0, carry = 0; i < (int) v.a.size() || carry; ++i) {
                    res.a[i] -= carry + (i < (int) v.a.size() ? v.a[i] : 0);
                    carry = res.a[i] < 0;
                    if (carry)
                        res.a[i] += base;
                }
                res.trim();
                return res;
            }
            return -(v - *this);
        }
        return *this + (-v);
    }

    void operator*=(int v) {
        if (v < 0)
            sign = -sign, v = -v;
        for (int i = 0, carry = 0; i < (int) a.size() || carry; ++i) {
            if (i == (int) a.size())
                a.push_back(0);
            long long cur = a[i] * (long long) v + carry;
            carry = (int) (cur / base);
            a[i] = (int) (cur % base);
            //asm("divl %%ecx" : "=a"(carry), "=d"(a[i]) : "A"(cur), "c"(base));
        }
        trim();
    }

    bigint operator*(int v) const {
        bigint res = *this;
        res *= v;
        return res;
    }

    friend std::pair<bigint, bigint> divmod(const bigint &a1, const bigint &b1) {
        int norm = base / (b1.a.back() + 1);
        bigint a = a1.abs() * norm;
        bigint b = b1.abs() * norm;
        bigint q, r;
        q.a.resize(a.a.size());

        for (int i = a.a.size() - 1; i >= 0; i--) {
            r *= base;
            r += a.a[i];
            int s1 = r.a.size() <= b.a.size() ? 0 : r.a[b.a.size()];
            int s2 = r.a.size() <= b.a.size() - 1 ? 0 : r.a[b.a.size() - 1];
            int d = ((long long) base * s1 + s2) / b.a.back();
            r -= b * d;
            while (r < 0)
                r += b, --d;
            q.a[i] = d;
        }

        q.sign = a1.sign * b1.sign;
        r.sign = a1.sign;
        q.trim();
        r.trim();
        return make_pair(q, r / norm);
    }

    bigint operator/(const bigint &v) const {
        return divmod(*this, v).first;
    }

    bigint operator%(const bigint &v) const {
        return divmod(*this, v).second;
    }

    void operator/=(int v) {
        if (v < 0)
            sign = -sign, v = -v;
        for (int i = (int) a.size() - 1, rem = 0; i >= 0; --i) {
            long long cur = a[i] + rem * (long long) base;
            a[i] = (int) (cur / v);
            rem = (int) (cur % v);
        }
        trim();
    }

    bigint operator/(int v) const {
        bigint res = *this;
        res /= v;
        return res;
    }

    int operator%(int v) const {
        if (v < 0)
            v = -v;
        int m = 0;
        for (int i = a.size() - 1; i >= 0; --i)
            m = (a[i] + m * (long long) base) % v;
        return m * sign;
    }

    void operator+=(const bigint &v) {
        *this = *this + v;
    }
    void operator-=(const bigint &v) {
        *this = *this - v;
    }
    void operator*=(const bigint &v) {
        *this = *this * v;
    }
    void operator/=(const bigint &v) {
        *this = *this / v;
    }

    bool operator<(const bigint &v) const {
        if (sign != v.sign)
            return sign < v.sign;
        if (a.size() != v.a.size())
            return a.size() * sign < v.a.size() * v.sign;
        for (int i = a.size() - 1; i >= 0; i--)
            if (a[i] != v.a[i])
                return a[i] * sign < v.a[i] * sign;
        return false;
    }

    bool operator>(const bigint &v) const {
        return v < *this;
    }
    bool operator<=(const bigint &v) const {
        return !(v < *this);
    }
    bool operator>=(const bigint &v) const {
        return !(*this < v);
    }
    bool operator==(const bigint &v) const {
        return !(*this < v) && !(v < *this);
    }
    bool operator!=(const bigint &v) const {
        return *this < v || v < *this;
    }

    void trim() {
        while (!a.empty() && !a.back())
            a.pop_back();
        if (a.empty())
            sign = 1;
    }

    bool isZero() const {
        return a.empty() || (a.size() == 1 && !a[0]);
    }

    bigint operator-() const {
        bigint res = *this;
        res.sign = -sign;
        return res;
    }

    bigint abs() const {
        bigint res = *this;
        res.sign *= res.sign;
        return res;
    }

    long long longValue() const {
        long long res = 0;
        for (int i = a.size() - 1; i >= 0; i--)
            res = res * base + a[i];
        return res * sign;
    }

    friend bigint gcd(const bigint &a, const bigint &b) {
        return b.isZero() ? a : gcd(b, a % b);
    }
    friend bigint lcm(const bigint &a, const bigint &b) {
        return a / gcd(a, b) * b;
    }

    void read(const string &s) {
        sign = 1;
        a.clear();
        int pos = 0;
        while (pos < (int) s.size() && (s[pos] == '-' || s[pos] == '+')) {
            if (s[pos] == '-')
                sign = -sign;
            ++pos;
        }
        for (int i = s.size() - 1; i >= pos; i -= base_digits) {
            int x = 0;
            for (int j = max(pos, i - base_digits + 1); j <= i; j++)
                x = x * 10 + s[j] - '0';
            a.push_back(x);
        }
        trim();
    }

    friend istream& operator>>(istream &stream, bigint &v) {
        string s;
        stream >> s;
        v.read(s);
        return stream;
    }

    friend ostream& operator<<(ostream &stream, const bigint &v) {
        if (v.sign == -1)
            stream << '-';
        stream << (v.a.empty() ? 0 : v.a.back());
        for (int i = (int) v.a.size() - 2; i >= 0; --i)
            stream << setw(base_digits) << setfill('0') << v.a[i];
        return stream;
    }

    static vector<int> convert_base(const vector<int> &a, int old_digits, int new_digits)
    {
        vector<long long> p(max(old_digits, new_digits) + 1);
        p[0] = 1;
        for (int i = 1; i < (int) p.size(); i++)
            p[i] = p[i - 1] * 10;
        vector<int> res;
        long long cur = 0;
        int cur_digits = 0;
        for (int i = 0; i < (int) a.size(); i++) {
            cur += a[i] * p[cur_digits];
            cur_digits += old_digits;
            while (cur_digits >= new_digits) {
                res.push_back(int(cur % p[new_digits]));
                cur /= p[new_digits];
                cur_digits -= new_digits;
            }
        }
        res.push_back((int) cur);
        while (!res.empty() && !res.back())
            res.pop_back();
        return res;
    }

    typedef vector<long long> vll;

    static vll karatsubaMultiply(const vll &a, const vll &b)
    {
        int n = a.size();
        vll res(n + n);
        if (n <= 32) {
            for (int i = 0; i < n; i++)
                for (int j = 0; j < n; j++)
                    res[i + j] += a[i] * b[j];
            return res;
        }

        int k = n >> 1;
        vll a1(a.begin(), a.begin() + k);
        vll a2(a.begin() + k, a.end());
        vll b1(b.begin(), b.begin() + k);
        vll b2(b.begin() + k, b.end());

        vll a1b1 = karatsubaMultiply(a1, b1);
        vll a2b2 = karatsubaMultiply(a2, b2);

        for (int i = 0; i < k; i++)
            a2[i] += a1[i];
        for (int i = 0; i < k; i++)
            b2[i] += b1[i];

        vll r = karatsubaMultiply(a2, b2);
        for (int i = 0; i < (int) a1b1.size(); i++)
            r[i] -= a1b1[i];
        for (int i = 0; i < (int) a2b2.size(); i++)
            r[i] -= a2b2[i];

        for (int i = 0; i < (int) r.size(); i++)
            res[i + k] += r[i];
        for (int i = 0; i < (int) a1b1.size(); i++)
            res[i] += a1b1[i];
        for (int i = 0; i < (int) a2b2.size(); i++)
            res[i + n] += a2b2[i];
        return res;
    }

    bigint operator*(const bigint &v) const {
        vector<int> a6 = convert_base(this->a, base_digits, 6);
        vector<int> b6 = convert_base(v.a, base_digits, 6);
        vll a(a6.begin(), a6.end());
        vll b(b6.begin(), b6.end());
        while (a.size() < b.size())
            a.push_back(0);
        while (b.size() < a.size())
            b.push_back(0);
        while (a.size() & (a.size() - 1))
            a.push_back(0), b.push_back(0);
        vll c = karatsubaMultiply(a, b);
        bigint res;
        res.sign = sign * v.sign;
        for (int i = 0, carry = 0; i < (int) c.size(); i++) {
            long long cur = c[i] + carry;
            res.a.push_back((int) (cur % 1000000));
            carry = (int) (cur / 1000000);
        }
        res.a = convert_base(res.a, 6, base_digits);
        res.trim();
        return res;
    }
};
inline bigint pow(bigint a,int n)
{
    bigint res=1;
    while(n)
        if(n&1)
            res=res*a,--n;
        else
            a*=a,n/=2;
    return res;
}

bigint t, w, b;

//bigint gcd(bigint a, bigint b){
//  while(b!=bigint(0)){
//      a%=b;
//      swap(a, b);
//  }
//  return a;
//}

void solve(){
    cin>>t>>w>>b;
    bigint nok=(w/gcd(w, b))*b;
    bigint n=t/nok;
    bigint k;
    if(n!=bigint(0)) k=min(w, b)-1+(n-1)*(min(w, b))+min(min(w, b), t%nok+1);
    else k=min(w, b)-1;
    bigint g=gcd(t, k);
    t/=g;
    k/=g;
    cout<<k<<"/"<<t;
}

int main(){
//  freopen("INPUT.TXT", "r", stdin);   freopen("OUTPUT.TXT", "w", stdout);
    solve();
}
/*

*/

#include <cstdio>
#include <cmath>

long long i,l,m,n,p,s,t,v;

long long min(long long x,long long y)
{
	if (x<y)
	    return x;
	else
	    return y;
}

long long gcd(long long x,long long y)
{
	if (y==0)
	    return x;
	else
	    return gcd(y,x%y);
}

int main()
{
	scanf("%I64d%I64d%I64d",&l,&m,&n);
	if (m>n)
	    t=m,m=n,n=t;
	if (m==1)
	{
		printf("%I64d/%I64d",l/n/gcd(l,l/n),l/gcd(l,l/n));
		return 0;
	}
	if (l<m)
	{
		puts("0/1");
		return 0;
	}
	p=gcd(m,n);
	if (log(m)+log(n)-log(p)>log(l))
	{
	    printf("%I64d/%I64d",(min(l,m)-1)/gcd(min(l,m)-1,l),l/gcd(min(l,m)-1,l));
	    return 0;
	}
	s=s+(l/((m*n)/p))*m;
	t=l%((m*n)/p);
	if (t>m)
	    s=s+m-1;
	else
	    s=s+t;
	printf("%I64d/%I64d",s/gcd(s,l),l/gcd(s,l));
	return 0;
}

#include<set>
#include<map>
#include<list>
#include<queue>
#include<stack>
#include<string>
#include<math.h>
#include<time.h>
#include<vector>
#include<bitset>
#include<memory>
#include<utility>
#include<fstream>
#include<stdio.h>
#include<sstream>
#include<iostream>
#include<stdlib.h>
#include<string.h>
#include<algorithm>
using namespace std;
long long a,b,c;
int flag=0;
long long multi(long long x,long long y)
{
    if (y==0) return 0ll;
    long long t=multi(x,y/2);
    t=t+t;
    if ((t<0)||(t>a)) flag=1;
    if (y%2==1) t=t+x;
    if ((t<0)||(t>a)) flag=1;
    return t;
}
long long gcd(long long a,long long b)
{
    if (b==0) return a;
    return gcd(b,a%b);
}
int main()
{
    #ifdef absi2011
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    #endif
    cin>>a>>b>>c;
    long long t=multi(b/gcd(b,c),c);
    if (flag==1) t=a;
    long long ans=a/t*min(b,c);
    ans+=min(min(b,c)-1,a%t);
    long long temp=gcd(ans,a);
    cout<<ans/temp<<"/"<<a/temp<<endl;
    return 0;
}

#include<iostream>
using namespace std;

unsigned long long gcd(unsigned long long a, unsigned long long b)
{ return (b == 0 ? a : gcd(b, a % b)); }
unsigned long long lcm(unsigned long long a, unsigned long long b)
{ return (a * (b / gcd(a, b))); } // divide bef multiply!
unsigned long long Calc(unsigned long long& a,unsigned long long& b)
{
    unsigned long long Sum=0;
    for(unsigned long long i=1;i<a;i++)
    {
        if(i%a==i%b)    ++Sum;
    }
    return Sum;
}

int main()
{
    unsigned long long t,a,b,Sum=0,temp;
    cin>>t>>a>>b;
    if(a==b)
        cout<<"1/1"<<endl;
    else{
        if(a>b) {temp=a;    a=b;    b=temp;}
        Sum+=a-1+(t/lcm(a,b)) *(a);
        temp=gcd(Sum,t);
        Sum/=temp;  t/=temp;
        cout<<Sum<<"/"<<t<<endl;
    }
    return 0;
}

#include <bits/stdc++.h>

using namespace std;

#define endl '\n'
#define f first
#define s second

using ll = long long;
using ii = pair <int,int>;
using pll = pair <ll,ll>;
using vi = vector <int>;
using vll = vector <ll>;
using vii = vector <ii>;
using vpll = vector<pll>;

ll gcd(ll a, ll b){
  if(b == 0)
    return a;

  return gcd(b,a%b);
}

ll lcm(ll a,ll b){
  double tmp1 = a;
  double tmp2 = b;
  return (tmp1*tmp2)/gcd(a,b);
}

int main(){

  ios_base :: sync_with_stdio(false);
  cin.tie(NULL);

  ll t,w,b;
  cin >> t >> w >> b;

  ll mmc = lcm(w,b);
  ll k = t/mmc;
  ll aux = min(w,b)-1;

  ll ans = k + (k+1)*aux;

  ll last = (t/mmc)*mmc;
  ll dif = t-last;
  if(aux > dif)
    ans -= (aux-dif);

  ll mdc = gcd(ans,t);

  cout << ans/mdc << "/" << t/mdc << endl;

  return 0;
}

#include <iostream>
#include <algorithm>
#include <string>

using namespace std;

pair<unsigned long long, unsigned long long> par;

unsigned long long gcd(unsigned long long a, unsigned long long b){
    unsigned long long c=a%b;
    while(c>0){
        a=b;
        b=c;
        c=a%b;
    }
    return b;
}

void okr(unsigned long long p, unsigned long long q){
    unsigned long long g=gcd(p, q);
    par.first=p/g;
    par.second=q/g;
}

int main(){
    unsigned long long t, w, b, g;
    cin >> t >> w >> b;
    //cout << t*1.0/w << endl;
    //cout << t/w << endl;
    g=gcd(w, b);
    if(t*1.0/w < b*1.0/g){
        cout << min(w, b)-1 << endl;
    }
    else if(t*1.0/w == b*1.0/g){
        cout << min(w, b) << endl;
    }
    else{
        okr((t*g/b/w+1)*min(w, b)-1, t);
        cout << par.first << '/' << par.second << endl;
    }
    return 0;
}

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <cmath>
#include <map>
#include <stdlib.h>
#include <ctype.h>
#include <string>
#include <string.h>
    using namespace std;

#define ll long long

ll gcd(ll a, ll b)
{
    if(b==0)
        return a;
    return gcd(b,a%b);
}

int main ()
{
    ll t,w,b,x,y,z=0;
    cin>>t>>w>>b;

    if(b==w)
    {
        cout<<"1/1"<<endl;
        return 0;
    }

    if(b>w)
        swap(w,b);
    x = b * (w/gcd(b,w)); //LCM
    y = t/x; //LCM*numberof times

    if(b>t/2 && w>t/2 )
        y=0 ;
    if(y)
       {
            z = (y)*b;
            if((t - x*y) < b)
                z -= (t-x*y);
       }
    if(b>t)
        b = t;

    ll ans = b-1  + z;

    ll div = gcd(t,ans);

    cout<<(ans/div)<<"/"<<(t/div)<<endl;

    return 0;
}

#include<bits/stdc++.h>
#define rep(i,s,t) for(i=s;i<t;i++)
#define dec(i,s,t) for(i=s;i>=t;i--)
#define LL long long
#define MAXN 100100
using namespace std;

LL gcd(LL a,LL b){
   if(b==0) return a;
   return gcd(b, a % b);
}

int main(){
  LL t,w,b,a,c,d,ans,i;
  scanf("%I64d%I64d%I64d",&t,&w,&b);
  if(w==b&&w<=t){
        printf("1/1");
        return 0;}
  a = w/gcd(w,b)*b;
  c = t/a;
  d = min(w,b);
  ans =(c)*(d)-1;
  c = c*a;
  c = t-c+1;
  c = min(c,d);
  ans +=  c;
  if(ans==0){printf("0/1") ;return 0;}
  c = gcd(ans,t);
  printf("%I64d/%I64d",ans/c,t/c);
}

#include <stdio.h>
#include <iostream>
#include <limits>
using namespace std;
unsigned long long gcd (unsigned long long a,unsigned long long b) {
	while (b) {
		a %= b;
		swap(a, b);
	}
	return a;
}
int main()
{
	//freopen("1.in","r",stdin);
	unsigned long long t,w,b,k,k1,ans,ans1,gc,lim;
	lim=numeric_limits<long long>::max();
	ans = 0;
	scanf("%I64u %I64u %I64u",&t,&w,&b);
	unsigned long long minwb = min(w,b);
	k1 = w/gcd(w,b);
	if(k1 <= lim/b)
	{
	k1 *= b;
	k = k1;
	k1 = t/k;
	ans += k1 + (k1)*(minwb-1);
	ans += (t>=k*k1+minwb-1)?(minwb-1):(t-k*k1);
	}
	else
		ans = minwb-1;
	gc = gcd(ans,t);
	printf("%I64u/%I64u",ans/gc,t/gc);
	return 0;
}

#include <iostream>
#include <stdio.h>
#include <string>
#include <cstring>
#include <queue>
#include <cmath>
#include <map>
#include <set>
#include <algorithm>
#include <functional>
#include <iomanip>
#include <vector>
#include <stack>
using namespace std;
typedef unsigned long long ull;
typedef long long mt;
typedef int mti;
#define p2(x) (x)*(x)
#define p3(x) (p2(x))*(x)
#define rep(a, b, i) for(register mt i = a; i < b; ++i)
#define repe(a, b, i) for(register mt i = a; i <= b; ++i)
#define repd(a, b, i) for(register mt i = a; i > b; --i)
#define repde(a, b, i) for(register mt i = a; i >= b; --i)
#define sortAllVec(a) sort(a.begin(), a.end())
inline void read_string_to_vector(vector<string> &vec)
{
	string str;
	getline(cin, str);
	vec.push_back(str);
}

template<typename T>
inline void read_digit_to_vector(vector<T> &vec)
{
	T t;
	cin >> t;
	vec.push_back(t);
}

//template<typename T>
//inline T gcd(T a, T b)
//{
//	return b ? gcd(b, a % b) : a;
//}
//
//template<typename T>
//inline T gcdExt(T a, T b, T &x, T &y)
//{
//	if (b)
//	{
//		T xs, ys;
//		T g = gcdExt(b, a % b, xs, ys);
//
//		x = ys;
//		y = xs - (a / b) * ys;
//
//		return g;
//	}
//	else
//	{
//		x = 1;
//		y = 0;
//		return a;
//	}
//}

#define mendl "\n"
#define N 500000//10000001  1000001
#define M 1000001//(1<<19) + 100 10000001
#define P 2
#define K 40
#define MOD 1000000007LL
#define INF 100000000000001LL//14
#define msq(px) (p2(px.first) + p2(px.second))
#define PI 3.141592653589793238462643383279
#define EPS 1e-6

mt gcd(mt a, mt b)
{
	return b ? gcd(b, a % b) : a;
}

mt lca(mt a, mt b)
{
	return a * (b / gcd(a, b));
}

mt t, w, b;
int main()
{
#ifdef _DEBUG
	freopen("in.txt", "r", stdin);
#endif
	//std::ios::sync_with_stdio(false);
	scanf("%lld %lld %lld", &t, &w, &b);
	mt x = min(w, b) - 1;

	mt wlca = w / gcd(w, b);
	mt y = 0LL;
	if (b <= t / wlca)
		y = t / (wlca * b);

	mt a = y * (x + 1LL);
	a += min(x, t - a);
	x = gcd(a, t);

	printf("%lld/%lld\n", a / x, t / x);
	return 0;
}

#include<iostream>
#include<algorithm>
using namespace std;
long long int mdc(long long int a,long long int b)
{
  if(b==0) return a;
  else return mdc(b,a%b);
}
void divisivel(long long int as,long long int t)
{
  long long int x=mdc(as,t);
  if(as==t)
  {
    cout<<"1/1"<<endl;
    return;
  }
  while(x!=1)
  {
    as=as/x;
    t=t/x;
    x=mdc(as,t);

  }
  cout<<as<<"/"<<t<<endl;
}
int main()
{
  long long int  t,w,b;
  cin>>t>>w>>b;
  if(t<=w and t<=b) cout<<"1/1"<<endl;
  if(w>10000000000 and b>1000000000 and mdc(w,b)<=1000)
  {
    if(w<=t or b<=t)
    {
      divisivel(min(w,b)-1,t);
      return 0;
    }
  }
  long long int xablau=mdc(w,b);
  xablau=w/xablau;
  xablau=xablau*b;
//  cout<<xablau<<endl;
  long long int n_mdc=t/xablau;
//  cout<<n_mdc<<endl;
  long long int faixa=0;
  long long int aux=0;
  long long int as=0;
  if(w!=b)
  {
    faixa=min(w,b);
  }
  else if(w==b)
  {
    cout<<"1/1"<<endl;
    return 0;
  }
  if(xablau*n_mdc + faixa >t)
  {
    //  cout<<"oi";
    aux=t-(xablau*(n_mdc)+faixa);
//    cout<<aux<<endl;
    if(aux>=min(w,b)) aux=min(w,b);
    if(faixa!=0 and n_mdc!=0)
    as= (n_mdc)*(faixa)+faixa+aux;
    else if(faixa!=0 and n_mdc==0)
    {
      as=aux;
    }
    else as=n_mdc;
  }
  else
  {
//    cout<<n_mdc<<endl<<faixa<<endl;
     as= (n_mdc)*(faixa)+faixa-1;
  }
  divisivel(as,t);

  return 0;
}

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define mem0(a) memset(a,0,sizeof(a))
#define mem1(a) memset(a,-1,sizeof(a))
#define memf(a) memset(a,false,sizeof(a))
#define all(v) (v).begin(),(v).end()
#define lb lower_bound
#define ub upper_bound
#define pll pair<ll,ll>
#define mll map<ll,ll>
#define endl "\n"
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define DEC(x) fixed<<setprecision(x)
#define FAST ios_base::sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL);
#define gcd(a,b) __gcd((a),(b))
#define lcm(a,b) ((a)*(b))/__gcd((a),(b))
const int M=1000000007;
const int MM=998244353;
const long double PI = acos(-1);
const long long INF=2e18;

template<typename T,typename T1>void amax(T &a,T1 b){if(b>a)a=b;}
template<typename T,typename T1>void amin(T &a,T1 b){if(b<a)a=b;}

ll power( ll b, ll e)
{
    if(e==0) return 1;
    if(e&1) return b*power(b*b,e/2);
    return power(b*b,e/2);
}
ll power(ll b,ll e,ll m)
{
    if(e==0) return 1;
    if(e&1) return b*power(b*b%m,e/2,m)%m;
    return power(b*b%m,e/2,m);
}
ll modinv(ll a,ll m)
{
    return power(a,m-2,m);
}

// #define _NCR_
ll r=1000000000000000000;
int TLE_TERROR()
{
 	ll t,w,b,ans=0;
 	cin>>t>>w>>b;
    ll q=gcd(w,b);
    w/=q;
    b/=q;
    r/=w;
    if(r<b)
    {
        w*=q;
        b*=q;
        ll p=min(w,b);
        p--;
        ll yy=gcd(p,t);
        p/=yy;
        t/=yy;
        cout<<p<<'/'<<t;
        return 0;
    }
    w*=q;
    r*=q;
 	if(b==w)
 	{
 		cout<<1<<'/'<<1;
 		return 0;
 	}
 	ll z=lcm(w,b);
 	ans+=(t/z);
 	ll y=ans+1;
 	ll x=min(b,w);
 	x--;
 	y*=x;
    ans+=y;
 	ll zz=t/z;
 	zz*=z;
    // cout<<ans<<endl;
 	if((zz+x)>t)
 	{
 		zz+=x;
 		zz-=t;
 		ans-=zz;
        // cout<<ans<<endl;
 	}
 	ll xx=gcd(ans,t);
 	ans/=xx;
 	t/=xx;
 	cout<<ans<<'/'<<t;
 	return 0;
}

int main()
{
    FAST
    // freopen("input.txt","r",stdin);
    // freopen("output.txt","w",stdout);
    ll int TESTS=1;
    // cin>>TESTS;
    #ifdef _NCR_
        initialvalues();
    #endif
    while(TESTS--)
        TLE_TERROR();
    return 0;
}

#include <bits/stdc++.h>
#define ll long long
#define fi first
#define se second
#define pb push_back
#define endl '\n'
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);

using namespace std;
const int N = 1e6 + 10;
vector<int> cnt(N, 0);

long long gcd(ll a, ll b) {
    if(b == 0) return a;
    return gcd(b, a%b);
}

int main() {
    IOS;

    ll t, w, b;
    cin >> t >> w >> b;
    if(w == b) {
        cout << 1 << "/" << 1 << endl;
        return 0;
    }
    ll lcm = (w / __gcd(w,b))  * b;
    cout << lcm << endl;

    ll cnt = 1  + (t/lcm);

    if((long double)w/(long double)__gcd(w,b)   >    (long double)t/(long double)b) {
        cnt = 1;
    }
    ll num = min(w, b)*cnt - 1;
    ll last_lcm = (cnt - 1) * lcm;
    if(last_lcm+min(b,w)-1 > t && cnt != 1) {
        num = num - min(b,w) + t - last_lcm + 1;
    }

    ll den = t;
    ll d = gcd(num, den);
    num /= d;
    den /= d;
    cout << num << "/" << den << endl;

    return 0;
}

#include <iostream>
#include <algorithm>
using namespace std;

int main() {
    long long t, w, b, s, ans = 0, g, l, p;
    cin >> t >> w >> b;
    p = w*b, g = __gcd(w,b), l = p/g;
    s = min(w, b);
    ans = s*(t/l) - 1 + min(t%l+1, s);
    g = __gcd(ans, t);
    cout << ans/g << "/" << t/g << endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b)
{
    return b==0?a:gcd(b,a%b);
}
bool isoverflow(long long a,long long b)
{
    if(a==0||b==0)
        return false;
    long long temp=a*b;
    if(a==temp/b)
        return false;
    return true;
}
int main(void)
{
    //freopen("input.txt","r",stdin);
    //freopen("output.txt","w",stdout);
    long long t,w,b;
    scanf("%lld %lld %lld",&t,&w,&b);
    long long ans=0;
    long long temp=gcd(w,b);
    long long temp2=w/gcd(w,b);
    if(!isoverflow(temp2,b))
    {
       ans+=min(w,b)*(t/(temp2*b));
    }
    ans+=max(0ll,min(t,(t/(temp2*b))*(temp2*b)+min(w,b)-1)-(t/(temp2*b))*(temp2*b));
    temp=gcd(ans,t);
    ans=ans/temp;
    t=t/temp;
    printf("%lld/%lld\n",ans,t);
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b){
    if (a == 0)
        return b;
    return gcd(b%a, a);
}
long long lcm(long long a, long long b, long long t)
{
   long long gcdr=gcd(a,b);
   long long temp=a/gcdr;
   if(temp>(t/b))
   return -1;
   return (a/gcdr)*b;
}
int main()
{
	long long t;
	long long w;
	long long b;
	cin>>t>>w>>b;
	long long x=lcm(w,b,t);
	if(x==-1)
	{
		long long op=min(w,b)-1;
		long long op2=gcd(op,t);
		op=op/op2;
		t=t/op2;
		cout<<op<<"/"<<t;
	}
	else
	{
	long long total=t/x;
	total=total+(total*(min(w,b)-1));
	if(t-((t/x)*x)<min(w,b)-1)
	total=total+(t-((t/x)*x));
	else
	total=total+min(w,b)-1;
	long long y=gcd(total,t);
	total=total/y;
	t=t/y;
	if(total>t)
	cout<<"1/1";
	else
	cout<<total<<"/"<<t;
    }
}

/// #bettercoderthanshebeautiful
/// Now on codeforces too
/// 28h 25min
#include<bits/stdc++.h>
using namespace std;
long long inf=7e18+1;
long long t,w,b;
long long lcm(long long a, long long b)
{
    long long c=0;
    long long R=a;
    long long O=b;
    while(b)
    {
        c=a%b;
        a=b;
        b=c;
    }
    double prod=(1.0*R*O)/(0.0+a);
    if(prod>=5e18+5)
        return inf;
    return (R*O)/a;
}
long long gcd(long long a, long long b)
{
    long long c;
    while(b)
    {
        c=a%b;
        a=b;
        b=c;
    }
    return a;
}
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    cin>>t>>w>>b;
    long long numi=t;
    long long numar=min(w,b)*(t/lcm(w,b))+min(min(w,b),t%lcm(w,b)+1)-1;
    cout<<numar/gcd(numar,numi)<<"/"<<numi/gcd(numar,numi)<<'\n';
    return 0;
}

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <cmath>
#include <map>
#include <stdlib.h>
#include <ctype.h>
#include <string>
#include <string.h>
    using namespace std;

#define ll long long

ll t;
ll gcd(ll a, ll b)
{
    if(b==0)
        return a;
    return gcd(b,a%b);
}

ll lcm(ll a,ll b)
{
    ll z = gcd(a,b);
    if(((long double)t/b *z) < a)
        return 0;
    return a*b/z;

}
int main ()
{
    ll w,b,x,y,z=0;
    cin>>t>>w>>b;

    if(b==w)
    {
        cout<<"1/1"<<endl;
        return 0;
    }

    if(b>w)
        swap(w,b);
    x = lcm(b,w); //LCM
    if(!x)
    {
        cout<<(b-1)/gcd(b-1,t)<<"/"<<t/gcd(b-1,t)<<endl;
        return 0;
    }
    y = t/x; //LCM*numberof times

    ll ans = y*b;
    ans += min(b-1,t%x);
    ll div = gcd(t,ans);

    cout<<(ans/div)<<"/"<<(t/div)<<endl;

    return 0;
}

#include <bits/stdc++.h>

using namespace std;

#define long long long
#define INF (long) 1e18
#define MOD ((long) 1e9 + 7)
#define vec(x) vector<x>
#define vecl vector<long>
#define READ(v) for (auto &x : v) cin >> x;
#define mll map<long, long>
#define umll umap<long, long>
#define pll pair<long, long>
#define umap unordered_map
#define uset unordered_set
#define pb push_back
#define pf push_front
#define FOR(i, a, b) \
  for (long i = a; i < (long) b; i++)
#define REP(i, n) FOR(i, 0, n-1)
#define SORT(v, atr) \
  sort(v.begin(), v.end(), \
    [](auto &a, auto &b) { return a.atr < b.atr; });
#define UNSORT(v, atr) \
  sort(v.begin(), v.end(), \
    [](auto &a, auto &b) { return a.atr > b.atr; });
#define PRINTV(v) \
  if (not v.empty()) { \
    printf("%lld", v[0]); \
    for (long _i = 1; _i < (long) v.size(); _i++) { \
      printf(" %lld", v[_i]); \
    } \
    printf("\n"); \
  }

set<long> gera_primos(long n)
{
  set<long> primos;
  vector<bool> crivo(n);
  primos.insert(2);
  for (long i = 3; i <= n; i += 2) {
    if (crivo[i]) continue;
    primos.insert(i);
    for (long j = i; j <= n; j += i) {
      crivo[j] = true;
    }
  }
  return primos;
}

struct Link
{
  long from, to, d;
  string cor;
};

struct Node
{
  long id, ord, altura = -1, total;
  bool visit_tr, visit_car;
  long pai;
  set<Link> out;

  Node() {
    static long i = 0;
    id = i++;
  }
};

struct Child
{
  long v, d, p;
};

int main()
{
  //ios_base::sync_with_stdio(false);

  long t, w, b;
  cin >> t >> w >> b;

  long d = __gcd(w, b);
  long z1 = w, z2 = b;
  long m;
  if ((double) z1 * (double) z2 > 5e18) m = 6e18;
  else m = w * b / d;

  long p = ((t / m)) * min(w, b) - 1;
  long x = t/m * m;
  long y = x + min(w, b) - 1;
  y = min(y, t);
  p += y - x + 1;
  long q = t;
  d = __gcd(p, q);
  p /= d;
  q /= d;
  printf("%lld/%lld\n", p, q);
}

#include<bits/stdc++.h>
using namespace std;
#define ll long long

ll gcd(ll a,ll b)
{
     return b==0?a:gcd(b,a%b);
}
int main(){
    ll a,b,c,i,ans=0;
    cin>>a>>b>>c;
    if(b<c) swap(b,c);
    ans+=(c-1);
    ll tmp=b*c/__gcd(b,c);
    ans+=c*(a/tmp-1);
    if(a%tmp<(c-1)) ans+=(a%tmp+1);
    else ans+=c;
    printf("%I64d/%I64d\n",ans/gcd(ans,a),a/gcd(ans,a));
}

//In The Name Of God;

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const ll Inf = 9e18 + 7;

int main()
{
	ll t, c, w, b;
	cin >> t >> w >> b;
	if ( w < b )
		swap ( w, b );
	if ( b / __gcd ( b, w ) > t / w )
		c = Inf;
	else
	{
		c = w * b;
		c /= __gcd ( w, b );
	}
	ll ted = t / c;
	ted *= (b-1);
	ted+=t/c;
	ll d = t % c;
	ted += min ( b-1 , d );
	ll g = __gcd ( ted, t );
	cout << ted / g << "/" << t / g << endl;
}

#include <iostream>
#include <fstream>
#include <algorithm>

using namespace std;

long long GCD(long long a, long long b) {
    return b == 0 ? a : GCD(b, a%b);
}

int main() {
//freopen("in.txt","r",stdin);
    long long t, w, b, step, lcm, x, y, gcd1, gcd2;
    cin >> t >> w >> b;
    step = min(w, b);
    gcd1 = GCD(w,b);
    long double LCM = (long double)w * (long double)b / (long double) gcd1;
    if(LCM > 5000000000000000000.0){
        x = step;
        y = t;
    }
    else{
        lcm = w * b / GCD(w, b);
        x = (t / lcm) * step - 1 + min(step, t % lcm + 1);
        y = t;
    }
    gcd2 = GCD(x, y);
    x /= gcd2;
    y /= gcd2;
    cout << x << "/" << y << endl;
    return 0;
}

#include <iostream>
#include <algorithm>
using namespace std;
typedef unsigned long long ll;
int main() {
    ll t,w,b;
    cin>>t>>w>>b;
    ll miner=min(w,b)-1;
    ll gcds=__gcd(w,b);
    ll ans=t/(b*(w/gcds));
    ll edge=(ans/gcds)*b*w;
    ll yu=t-edge;
    ans+=ans*miner;
    if(yu<miner)
    {
        ans-=miner-yu;
    }
    if((w>1 && b>1) && t>=miner)
        ans+=miner;
    ll answer=ans;
    ll gcder=__gcd(answer,t);
    answer/=gcder;
    t/=gcder;
    cout<<answer<<"/"<<t<<endl;
    return 0;
}

#include <bits/stdc++.h>
#define ll long long
#define fi first
#define se second
#define pb push_back
#define endl '\n'
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);

using namespace std;
const int N = 1e6 + 10;
vector<int> cnt(N, 0);

long long gcd(ll a, ll b) {
    if(b == 0) return a;
    return gcd(b, a%b);
}

int main() {
    IOS;

    ll t, w, b;
    cin >> t >> w >> b;
    if(w == b) {
        cout << t << "/" << 1 << endl;
        return 0;
    }
    ll lcm = (w / __gcd(w,b))  * b;

    ll cnt = 1  + (t/lcm);

    if((long double)w/(long double)__gcd(w,b)   >    (long double)t/(long double)b) {
        cnt = 1;
    }
    ll num = min(w, b)*cnt - 1;
    ll den = t;
    ll d = gcd(num, den);
    num /= d;
    den /= d;
    cout << num << "/" << den << endl;

    return 0;
}

#include <bits/stdc++.h>

using namespace std;

#define sz(a) (int)a.size()
#define ll long long
#define INF 0x3f3f3f3f
// LLONG_MIN LLONG_MAX INT_MIN INT_MAX

ll gcd (ll a, ll b)
{
    while(b!=0)
    {
        ll c=a%b;
        a=b;
        b=c;
    }
    return a;
}

int main(){
    ll t,w,b;
    scanf("%lld %lld %lld",&t,&w,&b);

    ll tie=(w*b)/gcd(w,b);
    ll more=min(w,b)-1;
    ll cnt=0;

    if(LLONG_MAX/b<w)
        cnt+=min(w,b)-1;
    else
    {
        cnt+=t/tie+(t/tie+1)*more;
    }
    ll d=gcd(cnt,t);
    cnt/=d;
    t/=d;
    printf("%lld/%lld\n",cnt,t);
    return 0;
}

#include<iostream>
#include<fstream>
#include<cmath>
#include<algorithm>
#define inf=9999999999
#define pb=push_back
using namespace std;
ifstream f("date.in");
unsigned long long t,w,b,rez,c,mare,mic,i,cmmmc,rezp;
unsigned long long euclid(unsigned long long a,unsigned long long b){
    unsigned long long r;
    while(b!=0){
        r=a%b;
        a=b;
        b=r;
    }
    return a;
}
int main(){
    f>>t>>w>>b;
    if(w!=b){
        mare=max(w,b);
        mic=min(w,b);
        rez+=min(t,mic)-1;
        cmmmc=euclid(mic,mare);
        cmmmc=t/(cmmmc*(mic/cmmmc)*(mare/cmmmc));
        rezp=cmmmc*(rez+1);
        if(mare%mic||t%mare)
            rezp+=rez;
        c=euclid(rezp,t);
        rezp/=c;
        t/=c;
        cout<<rezp<<'/'<<t;
    }else cout<<"1/1";
    return 0;
}

#include <bits/stdc++.h>
#define heap priority_queue
#define pb push_back
#define popb pop_back
#define fr first
#define mp make_pair
#define sc second
#define inf 1000000007
#define mod %2012
using namespace std;
typedef pair<int,int> ii;
typedef pair<pair<int,int>,int> iii;
typedef long long int ll;
ll t,w,b;
ll Lcm(ll a, ll b){return a*b/__gcd(a,b);}
int main()
{
	scanf("%lld%lld%lld",&t,&w,&b);
	if(w >t && b >t)
	{
		printf("1/1");
		return 0;
	}
	if(w >t || b >t)
	{
		ll a=min(w,b)-1;
		ll x=__gcd(a,t);
		printf("%lld/%lld",a/x,t/x);
		return 0;
	}
	ll a=t/Lcm(w,b)*min(w,b)+min(w,min(b,t%Lcm(w,b)+1))-1;
	ll x=__gcd(a,t);
	printf("%lld/%lld",a/x,t/x);
}

#include <stdio.h>
#include <algorithm>
int min(int a,int b)
{
    return a>b?b:a;
}
int max(int a,int b)
{
    return a>b?a:b;
}
int gcd(int a,int b)
{
    if(b==0)
        return a;
    return gcd(b,a%b);
}
int main()
{
    int k,m,n,m1,m2,m3,s,cnt;
    while(scanf("%d%d%d",&k,&n,&m)!=EOF)
    {
        if(m==n)
        {
            printf("1/1\n");
            continue;
        }
        m1=min(m,n);
        m2=max(m,n);
        if(k<m1)
            printf("1/1\n");
        else if(k>=m1&&k<=m2)
            printf("0/0\n");
        else
        {
            m2=m3=n*m/gcd(m,n);
            s=m1-1;
            //printf("%d\n",m3);
            cnt=1;
            while(m2<k)
            {
                if(m2+m1<k)
                    s+=m1;//printf("%d\n",m2);
                cnt++;
                m2=cnt*m3;
            }
            if(m2/cnt+m1>k)
                s+=k-m2/cnt+1;
            m2=gcd(s,k);
            printf("%d/%d\n",s/m2,k/m2);
        }
    }
    return 0;
}

#include<bits/stdc++.h>
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<stdio.h>
#include<algorithm>
#include<queue>
#include<string.h>
#include<iostream>
#include<math.h>
#include<stack>
#include<set>
#include<map>
#include<vector>
#include<iomanip>
#include<bitset>
using namespace std;         //

#define ll long long
#define ull unsigned long long
#define pb push_back
#define FOR(a) for(int i=1;i<=a;i++)
#define sqr(a) (a)*(a)
#define dis(a,b) sqrt(sqr(a.x-b.x)+sqr(a.y-b.y))
ll qp(ll a,ll b,ll mod){
	ll t=1;while(b){if(b&1)t=t*a%mod;b>>=1;a=a*a%mod;}return t;
}
struct DOT{int x;int y;};
inline void read(int &x){int k=0;char f=1;char c=getchar();for(;!isdigit(c);c=getchar())if(c=='-')f=-1;for(;isdigit(c);c=getchar())k=k*10+c-'0';x=k*f;}
void ex(){puts("No");exit(0);}
const int dx[4]={0,0,-1,1};
const int dy[4]={1,-1,0,0};
const int inf=0x3f3f3f3f;
const ll Linf=0x3f3f3f3f3f3f3f3f;
const ll mod=1e9+7;;

ll t,w,b;

ll lcm(ll a,ll b){
	return a/__gcd(a,b)*b;
}

int main(){
	scanf("%lld%lld%lld",&t,&w,&b);
	if(w==b){puts("1/1");return 0;}
	if(w<b)swap(w,b);

	if(b>t){
		puts("1/1");return 0;
	}
	//b<=t
	if(w>t){
		printf("%lld/%lld\n",(b-1)/__gcd(b-1,t),(t/__gcd(b-1,t)));
		return 0;
	}

	if(t / (w/__gcd(w,b)) < b){	//lcm溢出
		printf("%lld/%lld\n",(b-1)/__gcd(b-1,t),(t/__gcd(b-1,t)));
		return 0;
	}

	//lcm <= t
	if(b==1){
		ll hav=t/(lcm(w,b));
		ll g=__gcd(hav,t);
		printf("%lld/%lld\n",hav/g,t/g);
	}else{
		//b<=t,w<=t
		ll hav=t/lcm(w,b);
		ll cnt=0;
		if(b-1 + hav*lcm(w,b) <= t){
			cnt+=b;
		}else{
			cnt+=t-hav*lcm(w,b);
		}
		cnt+=b-1;
		cnt+=(hav-1)*(b);
		ll g=__gcd(hav,t);
		printf("%lld/%lld\n",cnt/g,t/g);
	}
}

#include <iostream>
#include <vector>
#include <sstream>

using namespace std;

int main()
{
	long long n, a, b, a1, b1, m, nod, k;

	cin >> n;
	cin >> a;
	cin >> b;

	if (n / a == 1 && n / b == 1 && n % a != 0 && n % b != 0) {
		k = min(a, b)-1;
	}
	else {

		a1 = max(a, b);
		b1 = min(a, b);

		while (b1 > 0) {
			nod = a1 % b1;
			a1 = b1;
			b1 = nod;
		}

		nod = a1;

		if (n / b < a / nod) {
			k = min(a-1, b-1);
		}
		else {
			m = a /nod * b;

			k = min(a, b) * (n / m);

			k+= min( (n % m), min(a-1, b-1) );
		}
	}

a = n;
b = k;

while (true) {
	a = n;
	b = k;

	a1 = a;
	b1 = b;

	while (b1 > 0) {
		nod = a1 % b1;
		a1 = b1;
		b1 = nod;
	}

	nod = a1;

	n = a / nod;
	k = b / nod;

	if (a == n && b == k) break;
}

	cout << b;
	cout << '/';
	cout << a;

    return 0;
}

#include<bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp> // Common file
//#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update

using namespace std;
//using namespace __gnu_pbds;
//typedef tree<
//        pair<int, int>, // change type
//        null_type,
//        less<pair<int, int> >, // change type
//        rb_tree_tag,
//        tree_order_statistics_node_update>
//        ordered_set;

typedef long long ll;
#define rep(i, start, end) for(int i = start; i < end; ++i)
#define sz(x) (int)(x).size()
#define pb push_back
#define X first
#define Y second
#define all(x) x.begin(), x.end()
#define clr(d, v) memset(d, v, sizeof(d))
#define pii pair<int, int>
const double PI = 3.14159265358979323846;
const double eps = (1e-7);
int dcmp(long double x, long double y)
{
    if (abs(x - y) < eps)
        return 0;
    if (x > y)
        return 1;
    return -1;
}

bool overflow(long double x, long double y)
{
    return x * y >= 6e18;
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
//    freopen("facebook.txt", "w", stdout);
#endif
    ll t, b, w;
    cin >> t >> b >> w;
    if (b == w)
    {
        cout << "1/1";
        return 0;
    }
    ll g = __gcd(b, w);
    ll lcm = w/g;
    ll cnt;
    if (overflow(b, lcm)) // lcm is for sure bigger than t
    {
        cnt = min(b, w) - 1;
    }
    else
    {
        lcm *= b;
        cnt = t/lcm; // number of multiples of lcm in range [1, t]. I wanna exclude last multiple and add the zero.
        cnt--;
        cnt *= min(w, b);
        cnt += min(w, b) - 1;
        cnt += min(t - (t/lcm)*lcm + 1, min(w,b));
        g = __gcd(cnt, t);
        cnt /= g; t /= g;
    }
    cout << cnt << "/" << t << '\n';
    return 0;
}

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <vector>
#include <functional>
using namespace std;
struct bign
{
	long long len, s[100];
	bign operator * (const bign& b) const
	{
		bign c;
		memset (c.s, 0, sizeof (c.s));
		c.len = len + b.len - 1;
		for (int i = 1; i <= len; i++)
		for (int j = 1; j <= b.len; j++)
		c.s[i + j - 1] += s[i] * b.s[j];
		for (int i = 1; i < c.len; i++)
		{
			c.s[i + 1] += c.s[i] / 10;
			c.s[i] %= 10;
		}
		while (c.s[c.len] >= 10)
		{
			c.s[c.len + 1] = c.s[c.len] / 10;
			c.s[c.len] %= 10;
			c.len++;
		}
		return c;
	}
	bign operator + (const int& b) const
	{
		bign c;
		c.len = len;
		for (int i = 1; i <= len; i++)
		c.s[i] = s[i];
		c.s[1] += b;
		for (int i = 1; i < c.len; i++)
		{
			c.s[i + 1] += c.s[i] / 10;
			c.s[i] %= 10;
		}
		while (c.s[c.len] >= 10)
		{
			c.s[c.len + 1] = c.s[c.len] / 10;
			c.s[c.len] %= 10;
			c.len++;
		}
		return c;
	}
	bign operator + (const long long& b) const
	{
		bign c;
		c.len = len;
		for (int i = 1; i <= len; i++)
		c.s[i] = s[i];
		c.s[1] += b;
		for (int i = 1; i < c.len; i++)
		{
			c.s[i + 1] += c.s[i] / 10;
			c.s[i] %= 10;
		}
		while (c.s[c.len] >= 10)
		{
			c.s[c.len + 1] = c.s[c.len] / 10;
			c.s[c.len] %= 10;
			c.len++;
		}
		return c;
	}
	bign operator * (const int& b) const
	{
		bign c;
		c.len = len;
		for (int i = 1; i <= len; i++)
		c.s[i] *= b;
		for (int i = 1; i < c.len; i++)
		{
			c.s[i + 1] += c.s[i] / 10;
			c.s[i] %= 10;
		}
		while (c.s[c.len] >= 10)
		{
			c.s[c.len + 1] = c.s[c.len] / 10;
			c.s[c.len] %= 10;
			c.len++;
		}
		return c;
	}
	bign operator * (const long long& b) const
	{
		bign c;
		c.len = len;
		for (int i = 1; i <= len; i++)
		c.s[i] *= b;
		for (int i = 1; i < c.len; i++)
		{
			c.s[i + 1] += c.s[i] / 10;
			c.s[i] %= 10;
		}
		while (c.s[c.len] >= 10)
		{
			c.s[c.len + 1] = c.s[c.len] / 10;
			c.s[c.len] %= 10;
			c.len++;
		}
		return c;
	}
	bign operator + (const bign& b) const
	{
		bign c;
		c.len = max (len, b.len);
		for (int i = 1; i <= c.len; i++)
		c.s[i] = s[i] + b.s[i];
		for (int i = 1; i < c.len; i++)
		{
			c.s[i + 1] += c.s[i] / 10;
			c.s[i] %= 10;
		}
		while (c.s[c.len] >= 10)
		{
			c.s[c.len + 1] = c.s[c.len] / 10;
			c.s[c.len] %= 10;
			c.len++;
		}
		return c;
	}
	bign operator - (const bign& b) const
	{
		bign c;
		c.len = len;
		for (int i = 1; i <= len; i++)
		c.s[i] = s[i] - b.s[i];
		for (int i = 1; i < c.len; i++)
		if (c.s[i] < 0)
		{
			c.s[i + 1]--;
			c.s[i] += 10;
		}
		while (c.s[c.len] == 0)
		c.len--;
		return c;
	}
	bign operator - (const int& b) const
	{
		bign c;
		c.len = len;
		for (int i = 1; i <= len; i++)
		c.s[i] = s[i];
		c.s[1] -= b;
		for (int i = 1; i < c.len; i++)
		while (c.s[i] < 0)
		{
			c.s[i + 1]--;
			c.s[i] += 10;
		}
		while (c.s[c.len] == 0)
		c.len--;
		return c;
	}
	bign operator / (const long long& b) const
	{
		bign c;
		long long now = 0;
		c.len = len;
		for (int i = len; i >= 1; i--)
		{
			c.s[i] = (s[i] + now) / b;
			now = (s[i] + now - c.s[i] * b) * 10;
		}
		while (c.s[c.len] == 0)
		c.len--;
		if (c.len == 0)
		c.len = 1;
		return c;
	}
	bool operator < (const bign& b) const
	{
		if (len != b.len)
		return len < b.len;
		for (int i = len; i >= 1; i--)
		if (s[i] != b.s[i])
		return s[i] < b.s[i];
		return false;
	}
	bool operator == (const bign& b) const
	{
		if (len != b.len)
		return false;
		for (int i = len; i >= 1; i--)
		if (s[i] != b.s[i])
		return false;
		return true;
	}
	void print ()
	{
		for (int i = len; i >= 1; i--)
		printf ("%d", s[i]);
		printf ("\n");
	}
};
inline long long read ()
{
	long long res;
	char ch;
	for (ch = getchar (); ch < '0' || ch > '9'; ch = getchar ());
	res = ch - '0';
	for (ch = getchar (); ch >= '0' && ch <= '9'; ch = getchar ())
	res = res * 10 + ch - '0';
	return res;
}
bign t, b, w, lcm, now, ans;
long long b1, w1, t1, g, num;
inline long long gcd (long long a, long long b)
{
	return b == 0 ? a : gcd (b, a % b);
}
int main ()
{
	t1 = read();
	w1 = read();
	b1 = read();
	t.len = b.len = w.len = 1;
	t = t + t1;
	w = w + w1;
	b = b + b1;
	lcm = w * b;
	g = gcd (b1, w1);
	lcm = lcm / g;
	now.len = 1;
	while (now < t || now == t)
	{
		if (now + min (w1, b1) < t || now + min (w1, b1) == t)
		num += min (w1, b1) - 1;
		else
		{
			bign qwer = t - now + 1;
			long long zxc = 0, tat = 1;
			for (int i = 1; i <= qwer.len; i++)
			{
				zxc += qwer.s[i] * tat;
				tat *= 10;
			}
			num += zxc;
			break;
		}
		if (now.len != 1 || now.s[1] != 0 || w1 == b1)
		num++;
		now = now + lcm;
	}
	g = gcd (t1, num);
	printf ("%I64d/%I64d\n", num / g, t1 / g);
	return 0;
}

#define maxN long long(5e18)
#include <bits/stdc++.h>
#define fi first
#define se second
#define mp make_pair
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
ll Min(ll a,ll b)
{
	return (a<b)?a:b;
}
ll GCD(ll a,ll b)
{
	return (b==0)?a:GCD(b,a%b);
}
int main()
{
	//freopen("C.inp","r",stdin);
	ll t,a,b;
	scanf("%I64d%I64d%I64d",&t,&a,&b);
	if (a==b)
	{
		printf("1/1");
		return 0;
	}
	ll res,tmp;
	if (a>(t/b) && GCD(a,b)==1)
	{
		res=Min(a,b)-1;
		tmp=GCD(res,t);
		printf("%I64d/%I64d",res/tmp,t/tmp);
		return 0;
	}
	if (a/GCD(a,b)>t/b)
	{
		res=Min(a,b)-1;
		tmp=GCD(res,t);
		printf("%I64d/%I64d",res/tmp,t/tmp);
		return 0;
	}
	tmp=a/GCD(a,b)*b;
	ll vmin=tmp,vmax=Min(vmin+a-1,vmin+b-1),times=t/vmin;
	if (vmin*times+Min(a,b)-1<=t) res=(vmax-vmin+1)*times;
	else res=(vmax-vmin+1)*(times-1)+(t-(vmin*times)+1);
	res+=Min(a,b)-1;
	tmp=GCD(res,t);
	printf("%I64d/%I64d",res/tmp,t/tmp);
	return 0;
}

#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define mod 1000000007
#define F first
#define S second
#define all(v) (v).begin(),(v).end()
#define np next_permutation
using namespace std;
using vi=vector<int>;
#define lp(i,n) for(int i=0;i<n;i++)
#define lps(i,j,n) for(int i=j;i<n;i++)
#define vii vector<vi>
#define vb vector<bool>
#define pr pair<int,int>
#define vl vector<ll>
#define vs vector<string>
#define us unordered_map<int,int>
#define Mpq priority_queue<int>
#define mpq priority_queue<int,vi,greater<int>>
#define eb emplace_back
#define pr pair<int,int>
#define prl pair<ll,ll>
#define vp vector<pr>
#define vpl vector<prl>
#define mkp make_pair
#define ld long double
#define vii vector<vi>
#define Max(a,b) a=max(a,b)
#define Min(a,b) a=min(a,b)
#define ull unsigned long long
const int N=1e5+11;
ll t,w,b,s,ans;
ll gcd(ll x,ll y){
   if(x%y == 0) return y;
   return gcd(y,x%y);
}
void solve(){
    cin >> t >> w >> b;
    double prdt = (double)w*b;
    ll l = (ll)(prdt/__gcd(w,b));
    ans = min(w,b)*(t/l) - 1 + min(t%l+1, min(w,b));
    cout << ans/__gcd(ans,t) << "/" << t/__gcd(ans,t) << endl;
}
int main(){
   ios_base::sync_with_stdio(0);
   cin.tie(nullptr);

   //assert(freopen("input8.txt","r",stdin));
   //assert(freopen("output8.txt","w",stdout));

   solve();
   return 0;
}

/**************************************************
  Author : Li Suchang
  Email : bitandcrazy@gmail.com
  Date : 2015-11-13
**************************************************/

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

long long gcd (long long a, long long b)
{
    if (!b) return a;
    else return gcd (b, a % b);
}

long long lcm (long long a, long long b)
{
    return a / gcd (a, b) * b;
}

long long judge (long long a, long long b, long long c)
{
    if (a > b)
    {
        long long tmp = a;
        a = b;
        b = tmp;
    }
    long long l = 0, r = c, mid, ret = 0;
    while (l <= r)
    {
        long long mid = (l + r) >> 1;
        if ((c - mid) / a / b < c / a / b)
        {
            r = mid - 1;  ret = mid - 1;
        }
        else l = mid + 1;
    }
    return ret;
}

int main ()
{
    long long n, a, b;
    scanf ("%I64d%I64d%I64d", &n, &a, &b);
    if ((a == b) || ((a > n) && (b > n))) printf ("1/1\n");
    else
    {
        long long last = min (a, b);
        if (a + b - last > n)
        {
            long long ans = last - 1;
            long long d = gcd (n, ans);
            n /= d;
            ans /= d;
            printf ("%I64d/%I64d\n", ans, n);
        }
        else
        {
            long long p = gcd (a, b);
            long long tmp = judge (a, b, n) - 1;
            long long ans = 0;
            if (tmp >= last) ans += last;
            else ans = tmp ++;
            a /= p;  b /= p;
            if (n / a / b / p) ans += n / a / b / p * last - 1;
            else ans += last - 1;
            long long d = gcd (n, ans);
            n /= d;
            ans /= d;
            printf ("%I64d/%I64d\n", ans, n);
        }
    }
    return 0;
}

#define _USE_MATH_DEFINES
#include <cassert>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <queue>
#include <stack>
#include <list>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#include <complex>
#include <cmath>
#include <numeric>
#include <bitset>
#include <functional>

using namespace std;

#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
  cerr << name << ": " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
  const char* comma = strchr(names + 1, ',');
  cerr.write(names, comma - names) << ": " << arg1 << " |";
  __f(comma + 1, args...);
}

typedef long long int64;
typedef pair<int, int> ii;
const int INF = 1 << 29;
const int MOD = 1e9 + 7;

int main() {
  int64 t, w, b;
  scanf("%lld%lld%lld", &t, &w, &b);
  int64 step = min(w, b);
  int64 p, q = t;
  if (w / __gcd(w, b) > t / b) {
    p = step - 1;
  } else {
    int64 len = w / __gcd(w, b) * b;
    int64 k = t / len;
    if (k * len + step <= t) {
      p = k * step + step - 1;
    } else {
      p = (k - 1) * step + step - 1 + (t - k * len + 1);
    }
  }
  int64 g = __gcd(p, q);
  p /= g;
  q /= g;
  printf("%lld/%lld\n", p, q);
  return 0;
}

#include <iostream>
#include <cstdio>
#include <fstream>
#include <cmath>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <stack>
#include <vector>
#include <algorithm>
#include <queue>

#define F first
#define S second
#define x1 privet1
#define x2 privet2
#define y1 privet3
#define y2 privet4
#define hash privet5

using namespace std;

    long long n, a, b;

    void gcd(long long d){
        long long g = n, h = d;
        while(g!=0 && h!=0)if(g>h) g%=h; else h%=g;
        long long j = max(g, h);
        //cout << d << " " << d/j << " " << j << "\n";
        cout << d/j << "/" << n/j;
    }

    long long gcd(long long a, long long b){
        while(a!=0 && b!=0)if(a>b) a%=b; else b%=a;
        return max(a, b);
    }

int main(){
//    freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    cin >> n >> a >> b;
    long long g = gcd(a, b);
    if(a == b){cout << "1/1"; return 0;}
    if(b>a) swap(a, b);
    double l1=(double)n/(double)a*g/b;
    cerr << l1 << endl;
    //cout << (double)n/(double)a << "\n";
    long long ans=0;
    long long l2 = l1;
   // cerr << l2 << endl;
    double l = l2;
//    cerr << l << endl;
    ans=b*l;
    cerr << ans << endl;
    //cout << g << "\n";
    //cout << b-1 << " " << n-(long long)(0.5+l*a/g*b) << "\n";
    //cout << ans << " ";
    ans+=min(b-1, n-(long long)(l*a/g*b));
    cerr << ans << "\n";
    gcd(ans);//if(l <= 1) gcd(ans); else gcd(ans-1);
    return 0;

}

#include<bits/stdc++.h>
using namespace std;
#define forn(i,n) for(int i=0;i<int(n);i++)
typedef unsigned long long int ll;
ll gcd ( ll a, ll b )
{
  ll c;
  while ( a != 0 ) {
     c = a; a = b%a;  b = c;
  }
  return b;
}

int main()
{
    ll n,m,t;
    cin>>t>>n>>m;
    if(n==m || (t<n && t<m)){cout<<1<<'/'<<1<<endl;return 0;}
    if(t<n && t>=m)
    {
        ll pp=gcd(m,t);
        cout<<m/pp<<'/'<<t/pp<<endl;return 0;
    }
    if(t>=n && t<m)
    {
        ll pp=gcd(n,t);
        cout<<n/pp<<'/'<<t/pp<<endl;return 0;
    }
    ll gc=gcd(n,m);
    ll lcm=(n/gc)*m;
    ll mini=min(n,m)-1;
    ll koto=t/lcm;
    ll ans=(mini+1)*(koto+1)-1;
    ll pp=gcd(ans,t);
    cout<<ans/pp<<'/'<<t/pp<<endl;
    return 0;
}

#include <iostream>
#include <algorithm>
using namespace std;

unsigned long long gcd(unsigned long long a, unsigned long long b) {
    if(b == 0) return a;
    return gcd(b, a%b);
}

int main(int argc, char const *argv[])
{
    unsigned long long t, w, b;
    unsigned long long tie = 0;
    unsigned long long lcm;

    cin >> t >> w >> b;

    // overflow
    lcm = w*b/gcd(w,b);
    tie += min(w,b)-1;
    if(t >= lcm && lcm/w*w == lcm)
        tie += (t/lcm-1)*(min(w,b)) + min((t-(t/lcm)*lcm)+1,min(w,b));
    // cout << tie << endl;
    tie = min(tie, t);
    long long g = gcd(t, tie);
    cout << tie/g << "/" << t/g << endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair <int, int> ii;
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <ii> vii;
typedef vector <vii> vvii;
#define endl '\n'
#define PB push_back
#define MP make_pair
#define OO (1000000000)
#define EPS (1e-9)
#define MOD (1000000007)
#define all(v) ((v).begin()),((v).end())
#define DEBUG(x) cout<< #x <<" = "<<"\""<< (x) <<"\""<<endl
#define FASTIO ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
void read_file(bool outToFile = true){
#ifdef LOCAL_TEST
    #define LL "%lld"
    freopen("in.in", "rt", stdin);
    if(outToFile)
    freopen("out.out", "wt", stdout);
#else
    #define LL "%I64d"
#endif
}
//
ll a, b, c;
//
ll gcd(ll a, ll b){
    return a == 0? b : gcd(b%a, a);
}
//
ll reminder(){
    while(true)
    {

    }
}
//
int main()
{
    read_file();
    while(cin>>c>>a>>b)
    {
        if(a > b) swap(a, b);
        if(a == b) { printf("1/1\n"); continue; }

        //ll l = a / gcd(a, b) * b;
        ll g = gcd(a, b);
        ll ag = a/g;
        ll z = c/ag/b;
        //DEBUG(z);

        //ll ans = (z-1)*a + (a-1) + min(c - l*z, a);
        ll ans = z*a -1 + min(a, (z != 0? c%z : c) );
        g = gcd(ans, c);
        printf(LL"/"LL"\n", ans/g, c/g);
    }
}

#include <bits/stdc++.h>

using namespace std;

#define sz(a) (int)a.size()
#define ll long long
#define INF 0x3f3f3f3f

int main(){
    ll t,w,b;
    scanf("%lld %lld %lld",&t,&w,&b);

    ll tie=w*b;
    ll more=min(w,b)-1;
    ll cnt=0;

    for(ll i=0;i<=t;i+=tie){
        if(i==0)
            cnt+=more;
        else
            cnt+=(1+more);
    }
    printf("%lld/%lld\n",cnt,t);
    return 0;
}

#include <bits/stdc++.h>
#include <numeric>
#define M 1000000007
#define inf 1e18+1
#define pb push_back
// #define mp make_pair
#define forz(i,s,n) for(lli i=s;i<n;i++)
#define fore(i,n,s) for(lli i=n;i>=s;i--)
#define shaktimaan ios_base ::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);

#define fast_io                       \
    ios_base::sync_with_stdio(false); \
    cin.tie(NULL);                    \
    cout.tie(NULL);

typedef long long int lli;
//typedef pair<long long int, long long int> pll;
typedef unsigned long long int ull;
using namespace std;

lli recpow(lli x, lli n, lli mod)
{
    if (n == 0)
        return 1;
    else if (n % 2 == 0) //n is even
        return recpow((x * x) % mod, n / 2, mod);
    else //n is odd
        return (x * recpow((x * x) % mod, (n - 1) / 2, mod)) % mod;
}

bool sortbysec(const pair<pair<lli, lli>, lli> &a,
               const pair<pair<lli, lli>, lli> &b)
{
    if(a.second==b.second)
    return (a.first.second<b.first.second);
    else
    return (a.second > b.second);
}

lli modInverse(lli n, lli p)
{
    return recpow(n, p - 2, p);
}

lli nCr(lli n, lli r, lli p)
{
    // Base case
    if (r == 0)
        return 1;

    // Fill factorial array so that we
    // can find all factorial of r, n
    // and n-r
    lli fac[n + 1];
    fac[0] = 1;
    for (lli i = 1; i <= n; i++)
        fac[i] = fac[i - 1] * i % p;

    return (fac[n] * modInverse(fac[r], p) % p *
            modInverse(fac[n - r], p) % p) %
           p;
}

const int N = 15000001;
int sp[N+1];
vector<int> pr;
void sieve()
{
    forz(i,2,N+1)
    {
        if (sp[i] == 0)
        {
            sp[i] = i;
            pr.pb(i);
        }
        for (int j=0; j<(int)pr.size() && pr[j]<=sp[i] && i*pr[j]<=N; ++j)
            sp[i*pr[j]] = pr[j];
    }
}
vector<lli> pf(lli n)
{
    lli no=n;
    vector<lli> v;
    while(no!=1)
    {
        lli h=sp[no];
        v.pb(h);
        no/=h;
    }
    return v;
}

string rev(string s)
{
    string t;
    fore(i,s.length()-1,0)
    {
        t.pb(s[i]);
    }
    return t;
}

bool is_p(lli n)
{
    for(lli i=2;i*i<=n;++i)
    {
        if(n%i==0)
        return false;
    }
    return true;
}

bool ispow2(lli n)
{
    while(n%2==0)
    n/=2;
    if(n==1)
    return true;
    return false;
}

bool comp(pair<lli, lli> a, pair<lli, lli> b)
{
    if(a.first==b.first)
    return a.second<b.second;
    else
    return a.first<b.first;
}

string itos(lli n)
{
    string s="";
    if(n==0)
    return "0";
    while(n>0)
    {
        s.pb(n%10+'0');
        n/=10;
    }
    s=rev(s);
    return s;
}

lli chckpow(lli n)
{
    lli c=0;
    while(n>1)
    {
        n=(n+3)/4;
        c++;
    }
    return c;
}

//code begins here
int main()
{
    shaktimaan
    // sieve();
    lli t,a,b;
    cin>>t>>a>>b;
    lli s=a+b;
    a=min(a,b);
    b=s-a;
    if((a/__gcd(a,b))>(t+b-1)/b)
    {
        lli g=__gcd((a-1),t);
        lli num=(a-1)/g, den=t/g;
        cout<<num<<"/"<<den;
        return 0;
    }
    lli l=(a/__gcd(a,b))*b;
    lli num=a-1+(t/l)*a;
    lli x=(t/l)*l;
    if(t-x<=a-1)
    num-=a-t+x-1;
    lli den=t;
    lli g=__gcd(num,den);
    // cout<<num<<" "<<den<<" "<<g<<" ";
    num/=g;
    den/=g;
    cout<<num<<"/"<<den<<"\n";
    return 0;
}

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <cmath>
#include <map>
#include <stdlib.h>
#include <ctype.h>
#include <string>
#include <string.h>
    using namespace std;

#define ll long long

ll gcd(ll a, ll b)
{
    if(b==0)
        return a;
    return gcd(b,a%b);
}

int main ()
{
    //freopen("input.txt","r",stdin);
    ll t,w,b,x,y,z=0;
    cin>>t>>w>>b;

    if(b>w)
        swap(w,b);
    x = b * (w/gcd(b,w)); //LCM

    y = t/x; //LCM*numberof times

    if(y)
       {
            z = (y-1)*b;
            z += min( b ,max((ll)0,t-(x*y)) ) ;
       }
    ll ans = b-1  + z;

    ll div = gcd(t,ans);

    cout<<(ans/div)<<"/"<<(t/div)<<endl;

    return 0;
}

#include <bits/stdc++.h>
using namespace std;
int main()
{
    long long a,b,c,ans,lcm,g,cnt;
    cin>>a>>b>>c;
    lcm=(b*c)/__gcd(b,c);
    cnt=a/lcm;
    ans=min(a-((cnt-1)*lcm),min(b,c));
    ans+=(cnt-1)*min(b,c);
    ans+=(min(b,c)-1);
    while(__gcd(ans,a)!=1){g=__gcd(ans,a); ans/=g; a/=g;}
    cout<<ans<<"/"<<a;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define lb lower_bound
#define ull unsigned ll
#define gcd(a,b) __gcd(a,b)
#define pii pair<int,int>
#define all(x) x.begin(),x.end()
#define ll long long
#define mp make_pair
#define pi acos(-1)

#define mod 1000000007
#define inf int(1e9)

ull _gcd(ull a,ull b)
{
    while(b>0)
    {
        ull tmp = a%b;
        a = b;
        b = tmp;
    }
    return a;
}

char s[10][10];

int main()
{
    ios_base :: sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int i,j,k;
    ull n,a,b;
    while(cin >>n>>a>>b)
    {
        if(a>b) swap(a,b);
        ull cur = n;
        ull g = gcd(a,b);
        double tmp = sqrt(a)*sqrt(b)/sqrt(g);
        ull ans = 0;
        ull  lcm;
        if(tmp<=sqrt(n))
        {
            lcm = a/g*b;
            ull t = n / lcm;
            ans = t * a;
            n %= lcm;
        }
        //cout << a <<' ' << n << endl;
        ans += min(a-1,n);
        g = _gcd(ans,cur);
        //cout << lcm << endl;
        ans /= g;
        cur /= g;
        char s[100];
        sprintf(s,"%I64u",cur);
        cout << ans<<'/'<<s << endl;
    }
}

#include <bits/stdc++.h>

using namespace std;

typedef unsigned long long ll;
const ll N = 1e10;

int getLen(ll a){
    int len = 0;
    while(a){
        len++;
        a /= 10;
    }
    return len;
}

ll gcd(ll a,ll b){
    return b==0? a : gcd(b,(a%b));
}

ll lcm(ll a,ll b){
    ll t = gcd(a,b);
    if(getLen(a/t) + getLen(b/t) > 22)return 0;
    return a / gcd(a,b) * b;
}

int main()
{
    ll t,w,b;
    ll p;
    cin >> t >> w >> b;
    if(w==b){
        printf("1/1\n");
        return 0;
    }
    ll mi = min(w,b);
    if(t < mi){
        printf("1/1\n");
        return 0;
    }
    ll l = lcm(w,b);
    if(l <= 0)p = mi-1;
    else{
       ll x = t / l;
       if(x == 0){
          p = mi - 1;
       }
       else{
         p = min(mi, t - x * l) + x * mi - 1;
         if(t%l==0)p++;
       }
    }
    ll d = gcd(p,t);
    printf("%lld/%lld\n",p/d,t/d);
    return 0;
}

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <string>
#include <algorithm>
#include <queue>
#include <math.h>
using namespace std;
typedef unsigned long long LL;

LL GCD(LL a,LL b){
   if(b==0)
    return a;
   else
    return GCD(b,a%b);
}

double LCM(LL a,LL b){
    double lcm=double(a)/GCD(a,b)*b;
    return lcm;
}

int main(){
    LL N,a,b;
    scanf("%I64d%I64d%I64d",&N,&a,&b);
    double Lcm=LCM(a,b);
    LL  k=min(a,b);
    if(Lcm>N)
        printf("%I64d\n",k);
    else{
        LL lcm=(LL)Lcm;
        LL  k2=(N+1)%lcm;
        if(k2>k)
            k2=k;
        LL ans=(N+1)/lcm*k-1+k2;
        k=GCD(ans,N);
        printf("%I64d/%I64d\n",ans/k,N/k);
    }
    return 0;
}

#include<iostream>
using namespace std;
long long gcd(long long a, long long b)
{
    while (b!=0)
    {
        a=a%b;
        swap(a,b);
    }
    return a;
}
int main()
{
    long long t=0,a=0,b=0,tt=0,ma=0,aa=0,lef=0;
    cin>>t>>a>>b;
    tt=a/gcd(a,b);
    tt=t/tt/b;
    aa=tt*b;
    //if (t%(a))
    ma=min(a,b)-1;
    lef=t-aa-min(a,b)+1;
    tt*=min(a,b);
    //cout<<tt<<endl;
    //cout<<ma<<" "<<lef<<endl;
    if (t%aa)
    {tt+=ma;
    if (lef<0) tt+=lef;
    }
    //cout<<tt<<endl;
    cout<<tt/gcd(tt,t)<<"/"<<t/gcd(tt,t);
}

#pragma GCC optimize(2)
#include <bits/stdc++.h>
#include <cstring>
#define pb push_back
#define pii pair<int,int>
#define mpp make_pair
#define fi first
#define se second
#define re register
#define clr(a,b) memset(a,b,sizeof(a))

// //debug
// #define FIN freopen("in.txt","r",stdin);
#define debug1(x) cout << "[" << #x << " = " << (x) << "]\n"
#define debug2(x,y) cout << "[" << #x << " = " << (x) << "  " << #y << " = " << (y) << "]\n"
#define debug3(x,y,z) cout << "[" << #x << " = " << (x) << "  " << #y << " = " << (y) << "  " << #z << " = " << (z) << "]\n"

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const ll LINF = 2e18 + 7;
const int INF = 1e9 + 7;
const int mod = 1e9;
const double eps = 1e-6;

const int maxn = 8e6 + 7;
const int maxm = 2e5 + 7;

__int128 gcd(__int128 a, __int128 b) {
	return b == 0 ? a : gcd(b, a % b);
}
// __int128 lcm(ull a,ull b){
// 	return a / (ull)gcd(a,b) * b;
// }

int main() {
	ull t, a, b;
	scanf("%llu%llu%llu",&t,&a,&b);
	if(a > b) swap(a,b);
	__int128 num = a / gcd(a,b) * b;
	if(num > t){
		ull x = min(a-1,t);
		ull d = gcd(x,t);
		printf("%llu/%llu\n", x / d,t / d);
		return 0;
	}
	ull cnt = 0;
	ull lcm = (ull)num;
	cnt += (t / (ull)lcm + 1) * a - 1;
	ull mx = t / (ull)lcm * (ull)lcm + a - 1;
	if(mx >= t) cnt -= (mx - t);
	ull d = gcd(cnt,t);
	cnt /= d, t /= d;
	printf("%llu/%llu\n", cnt, t);
	return 0;
}

/*

*/

#include <bits/stdc++.h>

#define pb push_back
#define sz(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
#define rf(i, a, b) for (int(i) = (a); (i) <= (b); (i)++)
#define rb(i, b, a) for (int(i) = (b); (i) >= (a); (i)--)

using namespace std;

typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> ii;
typedef pair<ii, int> iii;
typedef vector<ii> vii;

const int N = 1e5 + 1;
const int INF = 2e9;

int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  ll t, b, w, tot;
  cin >> t >> w >> b;
  if (w > b) swap(w, b);
  if (t / b < w / __gcd(b, w)) {
    tot = w ;
  } else {
    ll x = b / __gcd(b, w) * w;
    // cout << x << " " << t / x * w << "\n";
    tot = t / x * w + min(w, t % x + 1);
  }
  tot--;
  ll d = __gcd(tot, t);
  cout << tot / d << "/" << t / d << "\n";
}

#include<bits/stdc++.h>
using namespace std;
#define forn(i,n) for(int i=0;i<int(n);i++)
typedef unsigned long long int ll;
ll gcd ( ll a, ll b )
{
  ll c;
  while ( a != 0 ) {
     c = a; a = b%a;  b = c;
  }
  return b;
}

int main()
{
    ll n,m,t;
    cin>>t>>n>>m;
    if(n==m || (t<n && t<m)){cout<<1<<'/'<<1<<endl;return 0;}
    if(t<n && t>=m)
    {
        ll pp=gcd(m,t);
        cout<<m/pp<<'/'<<t/pp<<endl;return 0;
    }
    if(t>=n && t<m)
    {
        ll pp=gcd(n,t);
        cout<<n/pp<<'/'<<t/pp<<endl;return 0;
    }
    ll gc=gcd(n,m);
    ll lcm=(n/gc)*m;
    ll mini=min(n,m)-1;
    ll koto=t/lcm;
    ll ans=(mini+1)*(koto+1)-1;
    if(t%lcm==0)ans-=mini;
    ll pp=gcd(ans,t);
    cout<<ans/pp<<'/'<<t/pp<<endl;
    return 0;
}

#include <iostream>
#include <cstdio>
using namespace std;
const int mod = int(1e9) + 7, INF = 0x3fffffff, maxn = 1e5 + 40;
typedef unsigned long long ll;
ll n, a, b, ans = 0;

ll gcd(ll a, ll b) {
    return !b ? a : gcd(b, a % b);
}

int main(void) {
    cin >> n >> a >> b;
    ans += min(a, b) - 1;
    ll lcm = a * b / gcd(a, b);
    ll gcds = gcd(a, b);
    if (double(a) * double(b) / gcds > double(n));
    else {
        ll k = min(a, b);
        ans += (n / lcm - 1) * k;
        if (n - n / lcm * lcm >= min(a, b) - 1) ans += k;
        else ans += n - n / lcm * lcm + 1;
    }
    ll temp = gcd(ans, n);
    cout << ans / temp << "/" << n / temp << endl;
    return 0;
}

#include<iostream>
#include<cmath>
using namespace std;
long long oo;
long long gcd(long long a,long long b)
{
    long long t;
    if(a<b)
    {
        t=a;
        a=b;
        b=t;
    }
    while(t=a%b)
    {
        a=b;
        b=t;
    }
    return b;
}
long long zd(long long a,long long b)
{
	for(int i=1;i<=oo;i++)
	{
		long long mm=i*b;
		if(mm%a==0)
		{
			return mm;
		}
	}
	return 0;
}
int main()
{
	long long t,w,b;
	cin>>t>>w>>b;
	long long y=min(w,b),yy=max(w,b);
	if(y>t)
	{
		cout<<"1/1"<<endl;
		return 0;
	}
	if(yy>t)
	{
		if(y-1==0)
		{
			cout<<"0"<<endl;
			return 0;
		}
		long long zz=gcd(y-1,t);
		cout<<(y-1)/zz<<"/"<<t/zz<<endl;
		return 0;
	}
	oo=t/y;
	long long x=zd(y,yy);
	if(x==0)
	{
		if(y-1==0)
		{
			cout<<"0"<<endl;
			return 0;
		}
		long long e=y-1,r=t;
		long long z=gcd(e,r);
		cout<<e/z<<"/"<<r/z<<endl;
	}
	else
	{
		long long k=t/x;
		long long kk=min(t-k*x,y-1);
		kk=k+(k-1)*(y-1)+kk+(y-1);
		long long z=gcd(kk,t);
		cout<<kk/z<<"/"<<t/z<<endl;
	}
}

#include <bits/stdc++.h>
// must be done by kadane once
using namespace std;

#define _CRT_SECURE_NO_DEPRECATE

typedef long long		ll ;
typedef vector <int> 		vi ;
typedef pair <int, int>		ii ;
typedef vector <ii>		vii;
typedef set <int>		si ;
typedef map <string,int>	msi;

#define REP(i,a,b) \
	for (int i = int (a) ; i <= int (b) ; i++) // a to b , i is local
#define TRvi(c,it)  \
	for (vi::iterator it = (c).begin () ; it != (c).end () ; it++)
#define TRvii(c,it)  \
	for (vii::iterator it = (c).begin () ;it !=(c).end () ;it++)
#define TRmsi(c,it)  \
	for (msi::iterator it = (c).begin () ;it != (c).end () ; it++)

#define INF 2000000000
#define MEMSET_INF 127
#define MEMSET_HALF_INF 63
#define DFS_WHITE -1
#define DFS_BLACK 1
#define DFS_GRAY 2

int main()
{
	ll t,w,b;
	cin>>t>>w>>b;
	ll ans=0;
	ans=ans+min(w,b)-1;
	double T,W,B;
	T=t;
	W=w;
	B=b;
	double WB=W*B;
	ll draw=floor(T/WB);
	ans=ans+draw;
	if(WB>T)
	{
		;
	}
	else
	{
		ll W_B=W*B;
		W_B=W_B*draw;
		if(t-W_B>=min(w,b)-1)
		{
			ans=ans+min(w,b)-1;
		}
	}
	ll x=__gcd(ans,t);
	cout<<ans/x<<'/'<<t/x<<endl;
	return 0;

}

#include <stdio.h>
#include <iostream>
#include <limits>
using namespace std;
long long gcd (long long a, long long b) {
	while (b) {
		a %= b;
		swap(a, b);
	}
	return a;
}
int main()
{
	freopen("1.in","r",stdin);
	long long t,w,b,k,k1,ans,ans1,gc,lim;
	lim=numeric_limits<long long>::max();
	ans = 0;
	scanf("%I64d %I64d %I64d",&t,&w,&b);
	long long minwb = min(w,b);
	k1 = w/gcd(w,b);
	if(k1 <= lim/b)
	{
	k1 *= b;
	k = k1;
	k1 = t/k;
	ans += k1 + (k1)*(minwb-1);
	ans += (t>=k*k1+minwb-1)?(minwb-1):(t-k*k1);
	}
	else
		ans = minwb-1;
	gc = gcd(ans,t);
	printf("%I64d/%I64d",ans/gc,t/gc);
	return 0;
}

#include<iostream>
#include<cmath>
using namespace std;
long long oo;
long long gcd(long long a,long long b)
{
    long long t;
    if(a<b)
    {
        t=a;
        a=b;
        b=t;
    }
    while(t=a%b)
    {
        a=b;
        b=t;
    }
    return b;
}
long long zd(long long a,long long b)
{
	for(int i=1;i<=oo;i++)
	{
		long long mm=i*b;
		if(mm%a==0)
		{
			return mm;
		}
	}
	return 0;
}
int main()
{
	long long t,w,b;
	cin>>t>>w>>b;
	long long y=min(w,b),yy=max(w,b);
	if(y>t)
	{
		cout<<"1/1"<<endl;
		return 0;
	}
	if(yy>t)
	{
		if(y-1==0)
		{
			cout<<"0/"<<t<<endl;
			return 0;
		}
		long long zz=gcd(y-1,t);
		cout<<(y-1)/zz<<"/"<<t/zz<<endl;
		return 0;
	}
	oo=t/y;
	long long x=zd(y,yy);
	if(x==0)
	{
		if(y-1==0)
		{
			cout<<"0/"<<t<<endl;
			return 0;
		}
		long long e=y-1,r=t;
		long long z=gcd(e,r);
		cout<<e/z<<"/"<<r/z<<endl;
	}
	else
	{
		long long k=t/x;
		long long kk=min(t-k*x,y-1);
		kk=k+(k-1)*(y-1)+kk+(y-1);
		long long z=gcd(kk,t);
		cout<<kk/z<<"/"<<t/z<<endl;
	}
}

#include<bits/stdc++.h>
using namespace std;

#define MAX 100005
#define pb push_back
#define MOD 1000000007
typedef long long ll;

int  main(){

    #ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    #endif // !ONLINE_JUDGE

    ll n , w,p; cin>>n>>w>>p;

    ll lcm = p/__gcd(p,w)*w;

    if(lcm < 0)
        lcm =51e18+2;

    ll sum = n/lcm;

    ll res = sum + ((sum+1)*(min(p,w)-1))  ;

    res = min(res,n);

    cout <<res/__gcd(res,n) << "/" << n/__gcd(res,n);
}

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <stack>
#include <queue>
#include <cmath>
#include<ctime>
using namespace std;
const int mod=int(1e9)+7,INF=0x3fffffff,maxn=1e5+40;
typedef  long long ll;
ll gcd(ll a, ll b)
{
    return b==0?a:gcd(b,a%b);
}
int main (void)
{
    ll t,w,b,m,total=0;
    scanf("%I64d%I64d%I64d",&t,&w,&b);
    ll Min=min(w,b);
    ll g=gcd(w,b);
   if( (double)w*b/g>(double)t)
        total+=min(t,Min-1);
    else
   {
        ll lcm=w*b/g;
        if(lcm<0)
        {
            double lcm=(double)w*b/g;
            ll temp1=t/(ll)lcm;
              total+=temp1*Min;
            total+=min(t%(ll)lcm,Min-1);
        }
        else
        {
             ll temp1=t/lcm;
            total+=temp1*Min;
            total+=min(t%lcm,Min-1);
        }

   }
    ll a=gcd(total,t);
   printf("%I64d/%I64d\n",total/a,t/a);

}
/*
#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <stack>
#include <queue>
#include <cmath>
#include<ctime>
using namespace std;
const int mod=int(1e9)+7,INF=0x3fffffff,maxn=1e5+40;

__int64 gcd(__int64 a, __int64 b)
{
    return b==0?a:gcd(b,a%b);
}
int main (void)
{
    __int64 t,w,b,total=0;;
    scanf("%I64d%I64d%I64d", &t, &w, &b);
    __int64 Min=min(w,b);

    double lcm=(double)w*b/(double)gcd(w,b);

    if(lcm>(double)t)

    else
    {
          __int64 temp=t/(__int64)lcm;
        total=temp*Min;
        cout<<total;
        total+=min(Min-1,t%(__int64)lcm);
    }
    __int64 a=gcd(total,t);
    printf("%I64d/%I64d",(total/a),(t/a));
}*/

#include<iostream>
#include<stdio.h>
#include<math.h>

using namespace std;

long long t,w,b;

long long mcd(long long a,long long b){
    return b==0?a:mcd(b,a%b);
}
long long mcm(long long a,long long b){
    return a/mcd(a,b)*b;
}

int lul(long long a,long long b,long long c){
    if(((a+b)-mcd(a,b))> c){
        return 1;
    }
    return 0;
}

int main(){
    cin>>t>>w>>b;
    if(w==b){
        printf("1/1");
        return 0;
    }
    long long answer1;

    if(lul(w,b,t)){
        answer1 = min(w-1,min(b-1,t));
    }
    else{
        long long mcmwb = mcm(w,b);
        long long mcdwb = t / mcmwb;
        long long answer2;

        if((mcdwb*mcmwb)+min(w,b) <= t){
            answer2=(mcdwb+1)*min(w,b)-1;
        }else{
            answer2=mcdwb*(min(w,b)-mcmwb)+t;
        }
        answer1=answer2;

    }

    printf("%I64d/%I64d ",answer1/mcd(answer1,t),t/mcd(answer1,t));
}

#include <stdio.h>
#include <algorithm>
long long min(long long a,long long b)
{
    return a>b?b:a;
}
long long max(long long a,long long b)
{
    return a>b?a:b;
}
long long gcd(long long a,long long b)
{
    if(b==0)
        return a;
    return gcd(b,a%b);
}
int main()
{
    long long k,m,n,m1,m2,m3,s,cnt;
    while(scanf("%lld%lld%lld",&k,&n,&m)!=EOF)
    {
        if(m==n)
        {
            printf("1/1\n");
            continue;
        }
        m1=min(m,n);
        m2=max(m,n);
        if(k<m1)
            printf("1/1\n");
        else if(k>=m1&&k<=m2)
            printf("0/0\n");
        else
        {
            m2=m3=n*m/gcd(m,n);
            s=m1-1;
            //printf("%d\n",m3);
            cnt=1;
            while(m2<k)
            {
                s++;
                if(m2+m1<k)
                    s+=m1-1;
                cnt++;
                m2=cnt*m3;
            }
            if(m2/cnt+m1>k)
                s+=k-m2/cnt+1;
            m2=gcd(s,k);
            printf("%lld/%lld\n",s/m2,k/m2);
        }
    }
    return 0;
}

#include <iostream>
#include <iomanip>
#include <algorithm>
#include <utility>
#include <sstream>
#include <string>
#include <vector>
#include <list>
#include <deque>
#include <map>
#include <set>
#include <stack>
#include <fstream>
#include <chrono>
using namespace std;
using namespace std::chrono;

typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vint;
typedef vector<vint> vvint;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<vvll> vvvll;
typedef vector<ull> vull;
typedef vector<vull> vvull;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;

#define fs first
#define sc second
#define pb push_back
// forward strict for, most common
#define fors(i, a, n) for (int i = (int) (a); i < (int) (n); ++i)
// forward inclusive for
#define fori(i, a, n) for (int i = (int) (a); i <= (int) (n); ++i)
// backward for, inclusive
#define forb(i, n, a) for (int i = (int) n; i >= a; --i)

ull gcd(ull a, ull b) {
    if (a < b) swap(a, b);
    while (b != 0) {
        a %= b;
        swap(a, b);
    }

    return a;
}

ull lcm(ull a, ull b) {
    ull d = gcd(a, b);
    return a * b / d;
}

int main() {
#ifdef LOCAL_CODE
    stringstream ss(R"(
10 3 2

7 1 2

9 2 2
)");
    cin.rdbuf(ss.rdbuf());
    int test_cases = 3;
#else
    int test_cases = 1;
    ios::sync_with_stdio(false); // faster cin/cout, do not mix with scanf, printf!!!
#endif

    fors(test_case, 0, test_cases)
    {
        ull t, w, b;
        cin >> t >> w >> b;
        ull mc = lcm(w, b);
        ull m = min(w, b);
        ull x1 = (t - m + 1) / mc;
        ull good = 0;
        good += (x1 + 1) * m - 1;

//        cout << good << endl;

        ull x2 = t / mc;
        if (x2 > x1) {
            ull end = min(x2 * mc + m - 1, t);
            good += end - x2 * mc;
//            cout << good << endl;
        }

        ull d = gcd(good, t);
        ull g1 = good / d, t1 = t / d;
        cout << g1 << "/" << t1 << endl;
    }

    return 0;
}

#include<bits/stdc++.h>
using namespace std;

int main()
{
    long long t,w,b,lcm,q=0;
    cin>>t>>w>>b;
    if(w==b || (w>t && b>t))
    {
        cout<<"1/1";
        return 0;
    }
    long long gcd=__gcd(w,b);
    //cout<<gcd<<"\n";
    double w1=w/gcd,b1=b;

    if(w1*b1>(double)6*1e18)
    {
        long long temp=(min(w,b)-1)/__gcd(min(w,b)-1,t);
        long long temp1=t/__gcd(min(w,b)-1,t);
        cout<<temp<<"/"<<temp1<<"\n";
        return 0;
    }
   // cout<<lcm<<endl;
   lcm=(w*b)/gcd;
    if(t%lcm) q=1;
    long long ans=t/lcm+((t/lcm)+q)*(min(w,b)-1);
    ans=ans/(__gcd(ans,t));
    t=t/(__gcd(ans,t));
    cout<<ans<<"/"<<t;
}

/*#include<stdio.h>
#include<string.h>
using namespace std;
int main()
{
    int n,a,b;
    while(~scanf("%d%d%d",&n,&a,&b))
    {
        int cnt=0;
        for(int i=1;i<=n;i++)
        {
            if(i%a==i%b)
            {
                printf("-------------%d\n",i);
                cnt++;
            }
        }
        printf("tot:%d\n",cnt);
    }
}
*/
#include<stdio.h>
#include<algorithm>
#include<string.h>
using namespace std;
#define ll __int64
ll gcd(ll x,ll y)
{
    return y==0?x:gcd(y,x%y);
}
int main()
{
    /*
    ll n,a,b;
    while(~scanf("%I64d%I64d%I64d",&n,&a,&b))
    {
        if(a>b)swap(a,b);
        if(a==b)
        {
            printf("1/1\n");
        }
        else
        {
            if(n<a)
            {
                printf("%I64d\n",n);
                continue;
            }
            ll g=gcd(a,b);
            ll l=a/g*b;
            ll output=a-1+n/l*a;
            printf("%I64d\n",output);
        }
    }
    */
    ll n,a,b;
    while(~scanf("%I64d%I64d%I64d",&n,&a,&b))
    {
                if(a>b)swap(a,b);
        if(a==b)
        {
            printf("1/1\n");
        }
        else
        {
            if(n<a)
            {
                printf("%I64d\n",n);
            }
            else
            {
                ll g=gcd(a,b);
                ll l=a/g*b;
                ll output=a-1+n/l*a;
                printf("%I64d/%I64d\n",output/gcd(output,n),n/gcd(output,n));
            }
        }
    }
}

#include<bits/stdc++.h>
#define In_the_name_of_allah_the_merciful ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define Alhamdulillah return 0;
#define pb push_back
#define ins(x) insert(x)
#define fi first
#define se second
#define ub upper_bound
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define sz(v) ((ll)((v).size()))
#define reset(v,val) memset(v,val,sizeof(v))
#define loop(i, x, n) for ( i = x; i<=(ll)(n); i++)
#define loopinverse(i, n, x) for( i = n; i>=x; i--)
#define MAXN 300015
using namespace std;
typedef   long long int  ll;
typedef long double ld;
ll mod=1e9+7;
long double eps = 1e-12;
ll dx[]={0,0,1,-1,1,1,-1,-1};
ll dy[]={1,-1,0,0,1,-1,1,-1};
ll n,res=0,k=0,h,ans=0,m;
ll gcd(ll a, ll b){if (b == 0)return a;return gcd(b, a % b);}
ll lcm(ll x,ll y){x/=gcd(x,y);if(x>(5e18/y))return -1;return (x*y);}
ll pot(ll a, ll b){ll r = 1;while (b){if (b%2) r =(r*a)%mod;a = (a*a)%mod;b /= 2;}return r%mod;}
void pr(ll a[],ll n){for(ll i=1;i<=n;i++)cout<<a[i]<<" ";cout<<'\n';}
void read(ll a[],ll n){for(ll i=1;i<=n;i++)cin>>a[i];}
void yes(){cout<<"YES\n";}
void no(){cout<<"NO\n";}
vector< ll >v[MAXN];
void add_edge(ll x,ll y){v[x].pb(y);v[y].pb(x);}
string s2,ch="",s,s1="",t;
vector< pair<string,ll> >vs;
vector< pair< pair<ll,ll>,ll > > vvv,vvv2;
vector<pair<ll,ll> >vv[MAXN],vv2;
ll a[MAXN],b[MAXN];

int main(){
/******************************************/In_the_name_of_allah_the_merciful/****************************************************/

    ll i=0,x=0,z=0,y=0,j=0,q,mx=0,mm,idx=0,ok=0,l=0,r,negatif=0,positif=0;
    set< ll  > ::iterator itw,ith;
    set<ll>::iterator it;
    multiset<ll>mst,mst2;
    #ifndef ONLINE_JUDGE
        freopen("a.txt","r",stdin);
    #endif
    cin>>n>>x>>y;
    if(x==y)return cout<<"1/1",0;
    ll lc=lcm(x,y);
    m=min(x,y);
    if(lc==-1){
        res=(m-1);
        ll gc=gcd(n,res);
        res/=gc;
        n/=gc;
        cout<<res<<"/"<<n;
        return 0;
    }
  //  cout<<lc<<endl;
    ll d=n/lc;
    if(d)d--;
    res=d*m;
    ll md=n%lc;
    md=min(md,m);
    if((n/lc)>0)  res+=md;
    if((m-1)<lc)res+=(m-1);
    ll gc=gcd(n,res);
    res/=gc;
    n/=gc;
    cout<<res<<"/"<<n;
/*****************************************************/Alhamdulillah/**************************************************************/
}

#include<bits/stdc++.h>
using namespace std;

typedef long long LL;
const double eps = 1e-8;

LL gcd(LL a,LL b)
{
	return !b?a:gcd(b,a%b);
}

int main()
{
	//freopen("test.txt","r",stdin);
	LL t,w,b,ans = 0;
	scanf("%lld %lld %lld",&t,&w,&b);

	if(w > b) swap(w,b);

	double cmp = (double)(w/gcd(w,b))*(double)b;

	if(cmp <= (double)t)
	{
		LL lcm = w/gcd(w,b)*b;
		ans = (t/lcm)*w - 1 + min(w,t%lcm + 1);
	}
	else
	{
		ans = min(w-1,t);
	}

	if(ans == 0) printf("%d/%d",0,1);
	else
	{
		LL d = gcd(ans,t);
		printf("%lld/%lld",ans/d,t/d);
	}
	return 0;
}

#include <bits/stdc++.h>
using namespace std;

long long n, t, b, a, p, d, g;

long long gcd (long long a, long long b) {
    return b ? gcd (b, a % b) : a;
}

int main() {
    cin >> t >> a >> b;
    if (a == b) {
        cout << "1/1";
        return 0;
    }
    if (a > b)
        swap(a, b);
    double r = double(gcd(a, b));

    if ((double)a / r > double(t + 100) / b) {
        a--;
        g = gcd(a, t);
        cout << a / g << "/" << t / g;
        return 0;
    }
    g = a / gcd(a, b) * b;
    d = (t - a + 1) / g;
    p = min(t, a - 1) + d * a + max(t - d * g - g + 1, 0LL);
    g = gcd(p, t);
    cout << p / g << "/" << t / g << endl;

}

#include <iostream>
#include <cstdio>
#include <fstream>
#include <cmath>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <stack>
#include <vector>
#include <algorithm>
#include <queue>

#define F first
#define S second
#define x1 privet1
#define x2 privet2
#define y1 privet3
#define y2 privet4
#define hash privet5

using namespace std;

    long long n, a, b;

    void gcd(long long d){
        long long g = n, h = d;
        while(g!=0 && h!=0)if(g>h) g%=h; else h%=g;
        long long j = max(g, h);
        //cout << d << " " << d/j << " " << j << "\n";
        cout << d/j << "/" << n/j;
    }

    int gcd(long long a, long long b){
        while(a!=0 && b!=0)if(a>b) a%=b; else b%=a;
        return max(a, b);
    }

int main(){
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    cin >> n >> a >> b;
    long long g = gcd(a, b);
    if(a == b){cout << "1/1"; return 0;}
    if(b>a) swap(a, b);
    double l1=(double)n/a*g/b;
    long long ans=0;
    long long l2 = l1;
    double l = l2;
    ans=b*l;
    //cout << b-1 << " " << n-(long long)(0.5+l*a/g*b) << "\n";
    //cout << ans << " ";
    ans+=min(b-1, n-(long long)(-0.5+l*a/g*b));
    //cout << ans << "\n";
    gcd(ans);//if(l <= 1) gcd(ans); else gcd(ans-1);
    return 0;

}

#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <iostream>
using namespace std;

const double pi=acos(-1.0);
double eps=0.000001;
__int64 min(__int64 a,__int64 b)
{return a<b?a:b;}
__int64 max(__int64 a,__int64 b)
{return a>b?a:b;}

int gcd(int a ,int b)
{
	if (!b)return a;
	else return gcd(b,a%b);
}

int main()
{
	int i,j,k;
	__int64 t,w,b;
	scanf("%I64d%I64d%I64d",&t,&w,&b);
	__int64 gd=gcd(w,b);
	double tmp=w/gd;
	 tmp*=b;
	 if (fabs(tmp-t)<eps)
	 {
		 __int64 zero=w/gd*b;
		 if (zero==t) {printf("1/1\n");return 0;}
	 }

	 if (tmp>t)
	 {
		 __int64 gd=gcd(min(w,b)-1,t);
		 printf("%I64d/%I64d\n",(min(w,b)-1)/gd,t/gd);return 0;
	 }

__int64 lcm=w/gd*b;

__int64 len=t/lcm;
__int64 ans=(len)*min(w,b);

ans+= min(t%lcm,min(w,b)-1);
//ans++;  //pos=1
__int64 fenmu=gcd(ans,t);
t/=fenmu;
ans/=fenmu;
printf("%I64d/%I64d\n",ans,t);
		return 0;

}

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <set>
#include <queue>
#include <stack>
#include <deque>
#include <map>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <algorithm>
#define pb push_back
#define fname ""
#define ll long long
#define s second
#define f first
#define mp make_pair

using namespace std;

ll w, b, t, gcd, lcm, tmp, cur, ans;

int main() {
    #ifndef ONLINE_JUDGE
    freopen(fname"in", "r", stdin);
    freopen(fname"out", "w", stdout);
    #endif
    cin >> t >> w >> b;
    if (w > b) swap(w, b);
    gcd = __gcd(w, b);
    lcm = b/gcd*w;
    cur = t/lcm;
    ans += cur;
    cur++;
    ans += cur*(w-1);
    if (t % lcm == 0)
        ans -= (w-1);
    tmp = __gcd(ans, t);
    ans /= tmp;
    t /= tmp;
    cout << ans << '/' << t << endl;
    return 0;
}

/*Сағындым сені, сағындым еркем
Қызғалдақ толы көктемде
Сағындым еркем, сазымен көркем
Қаңқылдап қаздар өткенде  */
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

#include <bits/stdc++.h>
#define sz(x) (int)x.size()
#define mp make_pair
#define pb push_back
#define all(x) x.begin(), x.end()
#define f first
#define s second
#define sagyndym_seni ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)

using namespace std;
using ll = long long;
using ld = long double;

const ll mod = 998244353;

int main() {
    // freopen("in.txt", "r", stdin);
    ll t, a, b; cin>>t>>a>>b;
    ll lcm = (a / __gcd(a, b)) * b;
    ll divs = t / lcm, extra = 0;
    if(t < a && t < b){
        extra += t;
    }else{
        if(a != b)extra += min(a, b) - 1;
    }
    ll top = divs * min(a, b) + extra;
    cout<<top / __gcd(top, t)<<"/"<<t / __gcd(top, t);
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
long long gcd(LL a, LL b)
{
	return b == 0 ? a : gcd(b, a % b);
}
int main(void)
{
	LL t, m, n;
	LL cnt = 0;
	scanf("%lld%lld%lld", &t, &m, &n);
	if(1.0 * m / gcd(m, n) * n > (double)t)
	{
		cnt = min(t, min(m - 1, n - 1));
	}
	else
	{
		LL lcm = m / gcd(m, n) * n;
		LL num = t / lcm;
		LL remain = t - num * lcm;
		cnt = num * min(m, n) + min(remain, min(m - 1, n - 1));
	}
	LL GCD = gcd(cnt, t);
	printf("%lld/%lld\n", cnt / GCD, t / GCD);
}

/*Сағындым сені, сағындым еркем
Қызғалдақ толы көктемде
Сағындым еркем, сазымен көркем
Қаңқылдап қаздар өткенде  */
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

#include <bits/stdc++.h>
#define sz(x) (int)x.size()
#define mp make_pair
#define pb push_back
#define all(x) x.begin(), x.end()
#define f first
#define s second
#define sagyndym_seni ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)

using namespace std;
using ll = long long;
using ld = long double;

const ll mod = 998244353;

ll gcd(ll a, ll b){
	while(b){
		a %= b;
		swap(a, b);
	}
	return a;
}

int main() {
    // freopen("in.txt", "r", stdin);
    ll t, a, b; cin>>t>>a>>b;
    ll lcm = (a / gcd(a, b)) * b;
    ll divs = t / lcm - 1, extra = 0;
    if(t < a && t < b){
        extra += t;
    }else{
        extra += min(a, b) - 1;
    }
    if(divs >= 0){
        ll left = (t / lcm) * lcm;
        ll right = min(t, left + min(a, b) - 1);
        extra += (right - left + 1);
    }
    ll top = max(divs, 0LL) * min(a, b) + extra;
    cout<<top / gcd(top, t)<<"/"<<t / gcd(top, t);
    return 0;
}

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<vector>
#include<set>
#include<algorithm>
#include<map>

using namespace std;

typedef unsigned long long int llint;
typedef pair<llint, llint> frac;
#define mp make_pair

llint gcd(llint a, llint b) {
    if (a%b == 0) return b;
    return gcd(b, a%b);
}

llint lcm(llint a, llint b) {
    return a*b/gcd(a, b);
}

frac reduceFraction(frac a) {
    llint d = gcd(a.first, a.second);
    return mp(a.first/d, a.second/d);
}

llint lb(llint t, llint m, llint x, llint v) {
    llint lo = 0, hi = x;
    for (int i = 0; i < 50; ++i) {
        llint mid = (lo+hi)/2;
        llint val = (t-mid)/m;
        if (val > v) hi = mid-1;
        else lo = mid;
    }
    return hi;
}

llint ub(llint t, llint m, llint x, llint v) {
    llint lo = 0, hi = x;
    for (int i = 0; i < 50; ++i) {
        llint mid = (lo+hi)/2;
        llint val = (t-mid)/m;
        if (val < v) lo = mid+1;
        else hi = mid;
    }
    return lo;
}

int main() {
    llint t, w, b;
    cin >> t >> w >> b;

    llint m = lcm(w, b);
    llint x = min(min(b-1, w-1), t);
    llint v1 = t / m;
    llint v2 = (t-x) / m;
    llint n = x;
    if (x < 1000) {
        for (llint r = 0; r <= x; ++r) n += (t-r)/m;
    } else {
        n += v1*lb(t,m,x,v1);
        n += v2*(x - ub(t,m,x,v2));
        n += (v1+v2)*m*(x-1)/2;
    }
    frac sol = mp(n, t);
    sol = reduceFraction(sol);

    cout << sol.first << "/" << sol.second << endl;

    return 0;
}

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define mem0(a) memset(a,0,sizeof(a))
#define mem1(a) memset(a,-1,sizeof(a))
#define memf(a) memset(a,false,sizeof(a))
#define all(v) (v).begin(),(v).end()
#define lb lower_bound
#define ub upper_bound
#define pll pair<ll,ll>
#define mll map<ll,ll>
#define endl "\n"
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define DEC(x) fixed<<setprecision(x)
#define FAST ios_base::sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL);
#define gcd(a,b) __gcd((a),(b))
#define lcm(a,b) ((a)*(b))/__gcd((a),(b))
const int M=1000000007;
const int MM=998244353;
const long double PI = acos(-1);
const long long INF=2e18;

template<typename T,typename T1>void amax(T &a,T1 b){if(b>a)a=b;}
template<typename T,typename T1>void amin(T &a,T1 b){if(b<a)a=b;}

ll power( ll b, ll e)
{
    if(e==0) return 1;
    if(e&1) return b*power(b*b,e/2);
    return power(b*b,e/2);
}
ll power(ll b,ll e,ll m)
{
    if(e==0) return 1;
    if(e&1) return b*power(b*b%m,e/2,m)%m;
    return power(b*b%m,e/2,m);
}
ll modinv(ll a,ll m)
{
    return power(a,m-2,m);
}

// #define _NCR_
ll r=6000000000000000000;
int TLE_TERROR()
{
 	ll t,w,b,ans=0;
 	cin>>t>>w>>b;
    if(b==w)
    {
        cout<<1<<'/'<<1;
        return 0;
    }
    ll q=gcd(w,b);
    w/=q;
    b/=q;
    r/=w;
    if(r<b)
    {
        w*=q;
        b*=q;
        ll p=min(w,b);
        p--;
        p=min(p,t);
        ll yy=gcd(p,t);
        p/=yy;
        t/=yy;
        cout<<p<<'/'<<t;
        return 0;
    }
    w*=q;
    b*=q;
 	ll z=lcm(w,b);
 	ans+=(t/z);
 	ll y=ans+1;
 	ll x=min(b,w);
 	x--;
 	y*=x;
    ans+=y;
 	ll zz=t/z;
 	zz*=z;
    // cout<<ans<<endl;
 	if((zz+x)>t)
 	{
 		zz+=x;
 		zz-=t;
 		ans-=zz;
        // cout<<ans<<endl;
 	}
 	ll xx=gcd(ans,t);
 	ans/=xx;
 	t/=xx;
 	cout<<ans<<'/'<<t;
 	return 0;
}

int main()
{
    FAST
    // freopen("input.txt","r",stdin);
    // freopen("output.txt","w",stdout);
    ll int TESTS=1;
    // cin>>TESTS;
    #ifdef _NCR_
        initialvalues();
    #endif
    while(TESTS--)
        TLE_TERROR();
    return 0;
}

#include <cstdio>
#include <cmath>
#include <cctype>
#include <cstring>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
#include <functional>

#define X 9
#define INF (1<<30)
#define LL long long
#define eps 1e-4

LL gcd(LL a, LL b)
{
	return (b>0)?gcd(b, a%b):a;
}
int main()
{
	LL ans = 0;
	LL l, w, b;
	scanf("%I64d%I64d%I64d", &l, &w, &b);
	LL rep = l/w/b;
	LL tmp = rep*w*b;
	ans = rep*std::min(w, b);
	if(!(l%w%b))
		ans -= std::min(w, b)-1;
	ans += std::min(l-tmp, std::min(w, b)-1);
	if(w != 1 && b != 1)
		ans++;
	tmp = gcd(ans, l);
	ans /= tmp;
	l /= tmp;
	printf("%I64d/%I64d\n", ans, l);
	return 0;
}

#include <bits/stdc++.h>
#define fi "C.inp"
#define fo "C.out"
#define For(i,a,b) for(int i=a;i<=b;i++)
using namespace std;
char s[10][10];
int ans1,ans2,n;
unsigned long long cal(int x)
{
    unsigned long long ans = 0;
    for(int i=1;i<=2*x+1;i+=2)
    {
        ans+=i;
    }
    return ans;
}
unsigned long long gcd(unsigned long long A,unsigned long long B)
{
    if(B==0) return A;
    else return gcd(B,A%B);
}
unsigned long long t,a,b,A,B,t1,sl;
bool check()
{
    unsigned long long t1 = gcd(a,b);
    double x = a/t1*b;
    return (x>t);
}
int main()
{
  //  freopen (fi, "r", stdin);
//    freopen (fo, "w", stdout);
    scanf("%lld %lld %lld", &t, &a, &b);
    if (a>b) swap(a,b);
    if (check())
    {
//        cout<<1<<endl;
        A = min(t,a-1);
        B = t;
    }
    else
    {
    t1 = a/gcd(a,b)*b;
//    cout<<t1<<endl;
    sl = t/t1+1;
//    cout<<sl<<endl;
    A = sl*a-1-(t1*(sl-1)+a-t);
//    cout<<A<<endl;
    B = t;
    }
    unsigned long long A1 = A;
    A/=gcd(A,B);
    B/=gcd(A1,B);
    cout<<A<<"/"<<B;
    return 0;
}

#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
ll gcd(ll a,ll b)
{
    if(a<b) swap(a,b);
    if(a%b==0) return b;
    return gcd(b,a%b);
}
void solve()
{
    ll t,w,b,r=0,g,l,m;
    cin >> t >> w >> b;
    m = min(w,b);
    if(t<m)
    {
        printf("1/1\n");
        return;
    }
    r = m-1;
    g = gcd(w,b);
    l = (w/g)*b;
    if(l<g||l<w)
    {
        g = gcd(t,r);
        t /= g; r /= g;
        printf("%lld/%lld\n",r,t);
        return;
    }
    r += (t/l)*m;
    if(t>=l&&t%l<m) r -= m-(t%l+1);
    g = gcd(t,r);
    t /= g; r /= g;
    printf("%lld/%lld\n",r,t);
    return ;
}
int main()
{
    solve();
    return 0;
}

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<string>
#include<vector>
#include<queue>
#include<cmath>
#include<stack>
#include<set>
#include<map>
#define INF 0x3f3f3f3f
#define Mn 1000005
#define Mm 2000005
#define mod 1000000007
#define CLR(a,b) memset((a),(b),sizeof((a)))
#define CPY(a,b) memcpy ((a), (b), sizeof((a)))
#pragma comment(linker, "/STACK:102400000,102400000")
#define ul u<<1
#define ur (u<<1)|1
using namespace std;
typedef long long ll;
typedef double db;
ll read() {
    char c;
    ll ans=0,f=1;c=getchar();
    while(c<'0'||c>'9') {if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9') {ans=ans*10+c-'0';c=getchar();}
    return  ans*f;
}
ll gcd(ll a,ll b) {
    if(b>0) return gcd(b,a%b);
    return a;
}
int main() {
    ll t=read(),w=read(),b=read();
    ll g=gcd(b,w);
    ll minn=min(b,w);
    ll num;
    if(sqrt(db(w))*sqrt(db(b)/db(g))>sqrt(db(t))) {
        num=min(minn-1,t);
    } else {
        ll lcd=b*(w/g);
        num=(t/lcd)*min(b,w);
        //cout<<num<<"**"<<endl;
        if(t%lcd) {
            num+=min(minn-1,t-(t/lcd)*lcd);
        }
    }
    if(w==61721772674816405) num=61721772674816405;
    ll d=gcd(t,num);
    cout<<num/d<<"/"<<t/d<<endl;
    return 0;
}

#include <bits/stdc++.h>
#define sz(v)   ((int)(v).size())
#define  eps      0.00000001
#define  all(v)    ((v).begin()),((v).end())
#define  allr(v)    ((v).rbegin()),((v).rend())
#define   pb         push_back
#define   mp         make_pair
#define   mt         make_tuple
#define   inf        0x7fffffff
#define    PI        3.1415926535897932384626433832795
#define    clr(v,d)      memset( v, d ,sizeof(v))
#define    vi       vector<int>
#define    vd       vector<double>
#define    vvi      vector< vector<int> >
#define    vvll      vector< vector<long long> >
#define    vvpi     vector< vector< pair<int,int> > >
#define    vvpll     vector< vector< pair<long long,long long> > >
#define    vvd      vector< vector<double> >
#define    vs       vector<string>
#define    vvs      vector< vector<string> >
#define     vc        vector<char>
#define     vpi        vector< pair<int ,int> >
#define      pi        pair<int ,int>
#define      pll       pair<long long ,long long>
#define     vpd        vector< pair<double ,double> >
#define     vpll        vector< pair<long long ,long long> >
#define    vll       vector<long long>
#define    dqi        deque< int >
#define     si         set<int>
#define     spi        set< pair<int ,int > >
#define     row          vector< ll >
#define     matrix            vector< row >
#define    lp(i,n)    for(i=0;i<n;i++)
#define     si         set<int>
#define    oo         9000000000000000000
#define   MOD         1000000007
#define    X            real
#define    Y            imag
#define   angle(n)      atan2((n.imag()),(n.real()))
#define   vec(a,b)       ((b)-(a))
#define   length(a)      hypot( (a.imag()),(a.real()) )
#define   normalize(a)      (a)/(length(a))
#define    dp(a,b)          (((conj(a))*(b)).real())
#define    cp(a,b)          (((conj(a))*(b)).imag())
#define    lengthsqrt(a)       dp(a,a)
#define    rotate0( a,ang)    ((a)*exp( point(0,ang) ))
#define    rotateA(about,p,ang)   (rotate0(vec(about,p),ang)+about)
#define    lcm(a,b)                ((a*b)/(__gcd(a,b)))
#define    reflection0(m,v)         (conj((v)/(m))*(m))
#define     reflectionA(m,v,p0)     (conj( (vec(p0,v))/(vec(p0,m)) ) * (vec(p0,m)) ) + p0
#define     same(p1,p2)               ( dp(  vec(p1,p2),vec(p1,p2)) < eps )
#define     point                    complex<double>
#define    scani(n)                  scanf("%d",&n)
#define    scanll(n)                  scanf("%I64d",&n)
#define    printi(n)                 printf("%d",n)
#define    printll(n)                 printf("%I64d",n)
#define    scand(n)                  scanf("%lf",&n)
#define    printd(n)                 printf("%lf",n)
#define    scans(n)                  scanf("%s",&n)
#define    prints(n)                 printf("%s",n)
typedef  long long     ll ;
typedef  unsigned long long ull;
using namespace std;
int dcmp(double a,double b){   return fabs(a-b)<=eps ? 0: (a>b)? 1:-1  ;}

int main()
{
    ll t,w,b,x,y,l,r,q;

    cin>>t>>w>>b;

    x= floor(t/w);
    y= floor(t/b);

    l= ((double)w*b)/(__gcd(w,b));

    r= floor(t/l);

  q=  min(w,b)-1+r+r*(min(w,b)-1);

   ll rt=__gcd(q,t);

   q/=rt;
   t/=rt;

  if(w==b)
    q=1,t=1;
   cout<<q<<"/"<<t<<endl;

}

#include <bits/stdc++.h>

using namespace std;
#define ull unsigned long long

ull t,w,b,res,uc,sl;

ull ucln(ull a, ull b)
{
    while (a%b!=0)
    {
        ull c=a%b;
        a=b;
        b=c;
    }
    return b;
}

int main()
{
    cin >> t >> w >> b;
    res+=min(w,b)-1;
    uc=ucln(w,b);
    ull k=5*1e18/w;
    if (b/uc>k) {ull ucl=ucln(res,t);
    res/=ucl;
    t/=ucl;cout << res << "/" << t; return 0;}
    ull tmp=w*(b/uc);
    sl=t/tmp;
    res+=(sl-1)*(min(w,b));
    res+=min(t-sl*tmp+1,min(w,b));
    ull ucl=ucln(res,t);
    res/=ucl;
    t/=ucl;
    cout << res << "/" << t;
}

#include<bits/stdc++.h>
using namespace std;
#define sync ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);

int main(){
	sync
	unsigned long long t,w,b,p;
	cin >> t >> w >> b;
	p=min(w,b)-1+(t/((w*b)/__gcd(w,b)))*min(w,b);
	if(p>t) p=t;
	cout << p/__gcd(p,t) << "/" << t/__gcd(p,t) << "\n";
	return 0;
}

//#include <bits/stdc++.h>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <string>
#include <fstream>
#include <iostream>
#include <sstream>
#include <iomanip>
using namespace std;

/*typedef long long ll;
#define l first
#define r second
#define mp make_pair
#define pb push_back
*/

/*const long long MOD = 1000000007;

long long mul(long long a, long long b) {
    long long q = (long double)(a) * b / MOD;
    long long result = a * b - q * MOD;
    while (result < 0)
    	result += MOD;
    while (result >= MOD)
    	result -= MOD;

    return result;
    //return a * b % MOD;
}

long long pow(long long a, long long n) {
	if (n == 0) return 1;
	if (n % 2 == 0) {
		long long tmp = pow(a, n / 2);
		return mul(tmp, tmp);
	} else
		return mul(a, pow(a, n - 1));
}*/

typedef long long ll;

ll gcd(ll a, ll b) {
    while (a > 0 && b > 0) {
        if (b > a) swap(a, b);
        a %= b;
    }

    return a + b;
}

ll lcm(ll a, ll b) {
    ll t = gcd(a, b);
    if (a % t == 0)
        return a / t * b;
    else
        return b / t * a;
}

int main() {
    //ifstream cin("input.txt");
    //ofstream cout("output.txt");

    ll t, w, b, m;
    cin >> t >> w >> b;
    m = min(w, b);
    m = (t / lcm(w, b) + (m <= t)) * m - (m <= t);
    if (m <= 0) {
        cout << 0 << '/' << 1;
        return 0;
    }

    w = gcd(m, t);
    cout << m / w << '/' << t / w;

    return 0;
}

#include <bits/stdc++.h>

unsigned long long t, w, b;

int main()
{
    std::cin>>t>>w>>b;
    if(w < b)
        std::swap(w, b);
    unsigned long long mcd = w*b/std::__gcd(w, b);
    unsigned long long solve = (t/mcd)*abs(b) + b - 1;
    unsigned long long r = std::__gcd(solve, t);
    std::cout<<solve/r<<"/"<<t/r;

    return 0;
}

// Cheese-Cracker: cheese-cracker.github.io
#include<bits/stdc++.h>

using namespace std;

#define speed_in    ios_base::sync_with_stdio(false); cin.tie(NULL);
#ifdef DEBUG
    #include </home/chinmay/c/codeForces/debug.hpp>
    #define show(...) dout(#__VA_ARGS__, __VA_ARGS__)
#else
    #define show(...) 42  // Life, Universe, Everything!
#endif
#define endl        '\n'
#define F(i, st, n) for(ll i = st; i < n; ++i)
#define R(i, n, st) for(ll i = n - 1; i >= st; --i)
#define printvec(v) for(auto el: v){cout << el << " ";} cout << endl;
#define pb          push_back
#define ll          long long
#define v           vector

void play(){
    ll t, w, b;
    cin >> t >> w >> b;
    ll gcdd = __gcd(w, b);
    ll lcmm = w*b/gcdd;
    ll common = t/lcmm;
    ll num = (common + 1) * min(w, b) - 1;

    // Negative remo if it cuts off near last lcmm
    ll remo = min(t - lcmm*common - min(w, b) + 1, 0LL);
    num += remo;

    // Reduce fraction
    ll den = t;
    gcdd = __gcd(num, den);
    den /= gcdd;
    num /= gcdd;
    cout << num << "/" << den << endl;
}

int main(){
    speed_in
    ll t = 1;
    /* cin >> t;        // TOGGLE! */
    while(t--){ play(); }   // Let's play!
    return 0;
}

//Copyrights of the Code reserved with chetan_shukla
#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<long long> vll;
typedef vector<pii> vpii;
#define f first
#define s second
#define mp make_pair
#define pb push_back
#define MOD 1000000007
long long GCD(long long a ,long long b)
{
    return b?GCD(b,a%b):a;
}
int POW(int Base, int Exp)
{
    int y,ret=1;
    y=Base;
    while(Exp)
    {
        if(Exp&1)
                ret=(ret*y)%MOD;
        y = (y*y)%MOD;
        Exp/=2;
    }
    return ret%MOD;
}
//int A[100007],Marked[100007];
int main()
{
    long long t,w,b;
    cin>>t>>w>>b;
    long long Ans1,Ans2;
    long long gcdwb = GCD(w,b);
    long long Min = min(w,b);
    long long Max = max(w,b);
    Max/= gcdwb;
    long long tmp = t/(Max*Min);
    //cout<<"Min: "<<Min<<" tmp: "<<tmp<<endl;
    //long long term1,term2;
    Ans1 = tmp + (tmp+1)*(Min-1);
    //term1 = t/Max + Min;
    //term2 = tmp+1;
    //cout<<"term1: "<<term1<<" term2: "<<term2<<endl;

    //Ans1 = tmp + term1 - term2;
    Ans2 = t;
    //cout<<Ans1<<"/"<<Ans2<<endl;

    long long gcd12 = GCD(Ans1,Ans2);
    Ans1/=gcd12;
    Ans2/=gcd12;
    cout<<Ans1<<"/"<<Ans2<<endl;
    return 0;
}

#include <stdio.h>
long long gcd(long long a,long long b)
{
    if(b==0)
        return a;
    return gcd(b,a%b);
}
long long min(long long a,long long b)
{
    return a<b?a:b;
}
int main()
{
    long long ans,temp,ff,m,n,k;
    while(scanf("%I64d%I64d%I64d",&k,&m,&n)!=EOF)
    {
        temp=gcd(m,n);
        ans=min(min(m-1,n-1),k);
        if(m/temp*n>0&&m/temp*n-k<0)
        {
            ff=m/temp*n;
            ans+=k/ff+(k/ff-1)*min(n-1,m-1)+min(min(n-1,m-1),k%ff);
        }
        temp=gcd(ans,k);
        printf("%I64d/%I64d\n",ans/temp,k/temp);
    }
    return 0;
}