rational

#include <iostream>
#include <cstdio>
#include <vector>
#include <cstring>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <algorithm>
#include <sstream>
#include <cstdlib>
#include <cmath>
#include <random>
#include <bitset>
#include <cassert>
#include <tuple>
#include <list>
#include <iterator>
#include <unordered_set>
#include <unordered_map>

using namespace std;

typedef long long ll;
typedef long double ld;

#define mp make_pair
#define pb push_back
#define mt make_tuple

#define forn(i, n) for (int i = 0; i < ((int)(n)); ++i)
#define forrn(i, s, n) for (int i = (int)(s); i < ((int)(n)); ++i)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()

const int INF = 1791791791;
const ll INFLL = 1791791791791791791ll;

const int maxq = 1e5 + 179;

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

struct fraction {
    ll p, q;
    fraction() {}
    fraction(ll _p, ll _q) {
        p = _p;
        q = _q;
        ll g = gcd(p, q);
        p /= g;
        q /= g;
    }
};

ostream& operator<<(ostream& os, const fraction& f) {
    os << f.p << "/" << f.q;
    return os;
}

mt19937 rnd(179);

ll q;

ll num(fraction l, fraction r, ll i) {
    assert(l.p * r.q <= r.p * l.q);
    return ((i * r.p) / r.q) - ((i * l.p + l.q - 1) / l.q) + 1;
}

fraction random_in_range(fraction l, fraction r) {
    ll total = 0;
    for (ll i = 1; i <= q; i++) {
        total += num(l, r, i);
    }
    auto start = [&](const ll& i) -> ll {
        return (i * l.p + l.q - 1) / l.q;
    };
    ll rndval = rnd() % total;
    for (ll i = 1; i < q; i++) {
        if (rndval < num(l, r, i)) {
            return fraction(start(i) + rand() % num(l, r, i), i);
        }
        rndval -= num(l, r, i);
    }
    return fraction(start(q) + rand() % num(l, r, q), q);
}

vector<ll> divisors[maxq];
int num_of_prime_factors[maxq];

ll stat_in_range(fraction mid, fraction l, __attribute__((unused)) fraction r) {
    ll ans = 0;
    for (ll i = 1; i <= q; i++) {
        ll cans = 0;
        for (ll t : divisors[i]) {
            if ((num_of_prime_factors[t] % 2) == (num_of_prime_factors[i] % 2))
                cans += num(l, mid, t);
            else
                cans -= num(l, mid, t);
        }
        ans += cans;
    }
    return ans;
}

fraction solve(fraction l, fraction r, ll stat) {
    while (true) {
        fraction mid = random_in_range(l, r);
        ll mid_stat = stat_in_range(mid, l, r);
        if (mid_stat == stat)
            return mid;
        else if (mid_stat > stat)
            r = mid;
        else {
            stat -= mid_stat - 1;
            l = mid;
        }
    }
}

bool is_prime[maxq];
bool is_product_of_different_primes[maxq];

int main() {
    // Code here:

    cin >> q;
    memset(is_prime, 1, sizeof(is_prime));
    is_prime[0] = is_prime[1] = false;
    memset(num_of_prime_factors, 0, sizeof(num_of_prime_factors));
    memset(is_product_of_different_primes, 1, sizeof(is_product_of_different_primes));
    for (ll i = 2; i <= q; i++) {
        if (is_prime[i]) {
            num_of_prime_factors[i] = 1;
            for (ll j = i + i; j <= q; j += i) {
                ll k = j;
                while (k % i == 0) {
                    k /= i;
                    num_of_prime_factors[j]++;
                }
                is_prime[j] = false;
                is_product_of_different_primes[j] &= ((j / i) % i != 0);
            }
        }
    }

    for (ll i = 1; i <= q; i++) {
        if (is_product_of_different_primes[i]) {
            for (ll j = 1; i * j <= q; j++)
                divisors[i * j].pb(j);
        }
    }

    fraction l, r;
    cin >> l.p >> l.q >> r.p >> r.q;

    ll stat;
    cin >> stat;
    cout << solve(l, r, stat) << endl;

    return 0;
}