#include <bits/stdc++.h>

using i64 = long long;

struct SAM {
    struct Node {
        std::array<int, 26> nx{};
        int fa = 0, len = 0;
    };
    std::vector<Node> t;
    SAM() : t(2) {
        t[0].nx.fill(1);
        t[0].len = -1;
    }
    int extend(int p, int c) {
        if (t[p].nx[c]) {
            int q = t[p].nx[c];
            if (t[q].len == t[p].len + 1) {
                return q;
            }
            int r = int(t.size());
            t.push_back(t[q]);
            t[r].len = t[p].len + 1;
            t[q].fa = r;
            while (t[p].nx[c] == q) {
                t[p].nx[c] = r;
                p = t[p].fa;
            }
            return r;
        }
        int r = int(t.size());
        t.emplace_back();
        t[r].len = t[p].len + 1;
        while (t[p].nx[c] == 0) {
            t[p].nx[c] = r;
            p = t[p].fa;
        }
        int fa = extend(p, c);
        t[r].fa = fa;
        return r;
    }
};

int main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);

    std::string s;
    std::cin >> s;

    SAM sam;
    std::vector<int> pos;
    int u = 1;
    for (auto x : s) {
        u = sam.extend(u, x - 'a');
        pos.push_back(u);
    }

    std::vector<std::vector<int>> adj(sam.t.size());
    for (int u = 2; u < int(sam.t.size()); ++u) {
        adj[sam.t[u].fa].push_back(u);
    }

    std::vector<int> cnt(sam.t.size());
    for (auto u : pos) {
        ++cnt[u];
    }
    i64 ans = 0;
    auto dfs = [&](auto self, int u) -> void {
        for (auto v : adj[u]) {
            self(self, v);
            cnt[u] += cnt[v];
        }
        if (cnt[u] > 1) {
            ans = std::max(ans, 1ll * cnt[u] * sam.t[u].len);
        }
    };
    dfs(dfs, 1);
    std::cout << ans << "\n";

    return 0;
}