#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;
}

#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 <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 <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 <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);
}

#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;
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>
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 <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 <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>
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<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 <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 <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 <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);
}

/// #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<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 <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 <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;
}

#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;
}

/// #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;
}

#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 <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;
}

#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;

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<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<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 <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<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;
}

#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 <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;
}

///注意：会暴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<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 <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 <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<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;
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 <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 <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 <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 <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;

}

#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 <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;

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 <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 <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<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<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 <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>
#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 <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 <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>

#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 <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;
}

#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 <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 <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 <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<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<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 <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>
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<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;
}

/**********************************************************
 *     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;;;;;;;;;;; *
 ***********************************************************************************************************************************************************************************************************/

//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 <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 <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 <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);
    }
}

//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;
}

//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>

#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>
// #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 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<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 <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>
#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 <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;
    }
}

#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;
}

//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;
}

/*
######################################################
#    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<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 <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<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<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 <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 <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 <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;
}

#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 <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 <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;
}

#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;
}