#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <numeric>
using namespace std;

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

    bool operator<(const fraction& f) const {
        return p * f.q < q * f.p;
    }
};

const int N = 2e5 + 31, VN = 2 * N;

vector<char> s(N + 1);
vector<map<char, int>> t(VN);
vector<int> l(VN), r(VN), p(VN), suf(VN);
int n = 0, vn = 2, v = 1, pos = 0;

vector<set<int>> lens(VN);
fraction ans(1, 1);

int dfs(int v, int len) {
    // printf("%d %d\n", v, len);
    if (t[v].empty()) {
        lens[v].insert(len);
        return N;
    }
    int md = N;
    for (auto [c, u] : t[v]) {
        md = min(md, dfs(u, len + min(n, r[u]) - l[u]));
        if (lens[v].size() < lens[u].size()) {
            lens[v].swap(lens[u]);
        }
        for (int x : lens[u]) {
            auto it = lens[v].lower_bound(x);
            if (it != lens[v].end()) {
                md = min(md, *it - x);
            }
            if (it != lens[v].begin()) {
                --it;
                md = min(md, x - *it);
            }
            lens[v].insert(x);
        }
    }
    if (md != N) {
        ans = max(ans, fraction(len + md, md));
    }
    return md;
}

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

    string w;
    cin >> w;
    w += '$';
    for (char c = 0; c < 127; c++) {
        t[0][c] = 1;
    }
    l[1] = -1;

    for (n = 0; n < int(w.size()); n++) {
 		char c = s[n] = w[n];
		auto new_leaf = [&]( int v ) {
			p[vn] = v, l[vn] = n, r[vn] = N, t[v][c] = vn++;
		};
		go:;
		if (r[v] <= pos) { 
			if (!t[v].count(c)) {
				new_leaf(v), v = suf[v], pos = r[v];
				goto go;
			}
			v = t[v][c], pos = l[v] + 1;
		} else if (c == s[pos]) {
			pos++;
		} else {
			int x = vn++;
			l[x] = l[v], r[x] = pos, l[v] = pos;
			p[x] = p[v], p[v] = x;
			t[p[x]][s[l[x]]] = x, t[x][s[pos]] = v;
			new_leaf(x);
			v = suf[p[x]], pos = l[x];
			while (pos < r[x])
				v = t[v][s[pos]], pos += r[v] - l[v];
			suf[x] = (pos == r[x] ? v : vn);
			pos = r[v] - (pos - r[x]);
			goto go;
		}
	}
    
    for (auto [c, v] : t[1]) {
        if (c != '$') {
            dfs(v, min(n, r[v]) - l[v]);
        }
    }

    cout << ans.p << "/" << ans.q << "\n";

    return 0;
}