#include<bits/stdc++.h>

using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;
using f64 = long double;
using i128 = __int128_t;
using f128 = __float128;

#ifndef ONLINE_JUDGE
#include "algo\debug.hpp"
#else
#define debug(...) (void)42
#endif

template<class T>
constexpr void chmax(T& x, T y) {
    if (y > x) {
        x = y;
    }
}

template<class T>
constexpr void chmin(T& x, T y) {
    if (y < x) {
        x = y;
    }
}
struct PAM {
    static constexpr int ALPHABET = 26;
    static constexpr char OFFSET = 'a';
    struct Node {
        int len;
        int cnt;
        int suffixlink;
        std::array<int, ALPHABET>next;
        Node(): len{}, cnt{}, suffixlink{}, next{} {}
    };

    int suff;
    std::vector<Node>t;
    std::string s;

    PAM() {
        t.assign(2, Node());
        t[0].suffixlink = 1;
        t[1].suffixlink = 1;
        t[1].len = -1;
        suff = 0;
        s = "$";
    }

    int newNode() {
        t.emplace_back();
        return t.size() - 1;
    }

    int getfali(int u, int p) {
        while (p - t[u].len - 1 <= 0 or s[p - t[u].len - 1] != s[p]) {
            u = t[u].suffixlink;
        }
        return u;
    }

    void add(const char& c, int p) {
        s += c;
        int par = getfali(suff, p);
        if (not t[par].next[c - OFFSET]) {
            int cur = newNode();
            t[cur].suffixlink = t[getfali(t[par].suffixlink, p)].next[c - OFFSET];
            t[par].next[c - OFFSET] = cur;
            t[cur].len = t[par].len + 2;
            t[cur].cnt = t[t[cur].suffixlink].cnt + 1;
        }
        suff = t[par].next[c - OFFSET];
    }

    int size() {
        return t.size();
    }

    int next(int p, const char& c) {
        return t[p].next[c - OFFSET];
    }

    int link(int p) {
        return t[p].suffixlink;
    }

    int len(int p) {
        return t[p].len;
    }

    int cnt(int p) {
        return t[p].cnt;
    }

    std::vector<std::vector<int>>work() {
        std::vector adj(size(), std::vector<int>());
        for (int i = 2; i < size(); i += 1) {
            adj[link(i)].push_back(i);
        }
        return adj;
    }
};

auto main() ->int32_t {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout << std::fixed << std::setprecision(13);

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

    PAM pam;
    int n = s.size();
    s = ' ' + s;
    std::vector<int>end;
    for (int i = 1; i <= n; i += 1) {
        pam.add(s[i], i);
        end.push_back(pam.suff);
    }

    std::vector<int>f(pam.size());
    for (const auto& x : end) {
        f[x] += 1;
    }

    i64 ans = 0;
    for (int i = pam.size() - 1; i >= 2; i -= 1) {
        f[pam.link(i)] += f[i];
        ans = std::max(ans, i64(f[i]) * pam.len(i) * pam.len(i));
    }

    std::cout << ans << '\n';

    return 0;
}