#include <bits/stdc++.h>

using namespace std;
using ll = long long;

#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()
#define pb push_back
#define ff first
#define sc second

vector<int> manacher(string s) {
    vector<int> ans(s.size());
    int l = -1, r = -1;
    for (int i = 0; i < s.size(); i++) {
        if (i > r) {
            l = i; r = i;
            while (l - 1 >= 0 && r + 1 < s.size() && s[l - 1] == s[r + 1]) { r++; l--; }
            ans[i] = r - l + 1;
        } else {
            int cl = ans[l + r - i];
            if (cl / 2 + i < r) {
                ans[i] = cl;
            } else {
                ans[i] = 1 + (r - i) * 2;
                while (r + 1 < s.size() && 2 * i - (r + 1) >= 0 && s[r + 1] == s[2 * i - (r + 1)]) {
                    ans[i] += 2;
                    r++;
                    l = 2 * i - r;
                }
            }
        }
    }
    return ans;
}

const ll mod1 = 1e9 + 7, mod2 = 998244353;
const ll p = 31;

struct polyhash {
    int n;
    vector<int> c;
    vector<pair<ll, ll>> h, ppow;
    polyhash() = default;
    polyhash(int n_, vector<int> c_) {
        n = n_;
        c = c_;
        h.assign(n + 1, {0, 0});
        ppow.assign(n + 1, {1, 1});
        for (int i = 1; i <= n; i++) {
            h[i] = {(h[i - 1].first * p + c[i - 1]) % mod1, 
                    (h[i - 1].second * p + c[i - 1]) % mod2};
            ppow[i] = {(ppow[i - 1].first * p) % mod1, 
                       (ppow[i - 1].second * p) % mod2};
        }
    }

    pair<ll, ll> substring(int l, int r) {
        // [l, r] is segment in 0-index
        return {(h[r + 1].first + mod1 - (h[l].first * ppow[r - l + 1].first) % mod1) % mod1, 
                (h[r + 1].second + mod2 - (h[l].second * ppow[r - l + 1].second) % mod2) % mod2};
    }

    int find_lcp(int p1, int p2) {
        // finds longest common prefix of suffixes starts with indexes p1 and p2
        // useful for suffix array
        int L = 0, R = min(n - p1, n - p2) + 1;
        while (R - L > 1) {
            int M = (L + R) / 2;
            if (substring(p1, p1 + M - 1) == substring(p2, p2 + M - 1)) L = M;
            else R = M;
        }
        return L;
    }
};

struct sufarr {
    int n;
    vector<int> a;
    vector<int> cl;
    sufarr() = default;
    sufarr(int n_, vector<int> a_) {
        n = n_;
        a = a_;
        build();
    }
  
    void build() {
        vector<int> ord(n);
        iota(all(ord), 0);
        sort(all(ord), [&](int i, int j){return a[i] < a[j];});
  
        vector<pair<int, int>> lol(n);
        cl.assign(n, 0);
        int cur = -1;
        for (int i = 0; i < n; i++) {
            if (i == 0 || a[ord[i]] != a[ord[i - 1]]) cur++;
            cl[ord[i]] = cur;
        }
        for (int len = 2; len < 2 * n; len *= 2) {
            int l2 = len / 2;
            for (int i = 0; i < n; i++) {
                lol[i] = {cl[i], (i + l2 < n ? cl[i + l2] : -1)};
            }
            
            iota(all(ord), 0);
            vector<int> no(n);
            {
                vector<vector<int>> bs(n + 1);
                for (int i = 0; i < n; i++) bs[lol[ord[i]].second + 1].pb(ord[i]);
                int cur = 0;
                for (int i = 0; i <= n; i++) {
                    for (int el : bs[i]) no[cur++] = el;
                }
                swap(no, ord);
            }
            {
                vector<vector<int>> bs(n);
                for (int i = 0; i < n; i++) bs[lol[ord[i]].first].pb(ord[i]);
                int cur = 0;
                for (int i = 0; i < n; i++) {
                    for (int el : bs[i]) no[cur++] = el;
                }
                swap(no, ord);
            }
            int cur = -1;
            for (int j = 0; j < n; j++) {
                if (j == 0 || lol[ord[j]] != lol[ord[j - 1]]) cur++;
                cl[ord[j]] = cur;
            }
        }
    }
};

struct fenwick {
    int n;
    vector<int> t;
    fenwick() = default;
    fenwick(int n_) {
        n = n_;
        t.assign(n + 1, 0);
    }
 
    void upd(int p, int vl) {
        for (; p <= n; p = (p | (p + 1))) t[p] += vl;
    }
 
    int get(int p) {
        int sm = 0;
        for (; p > 0; p = (p & (p + 1)) - 1) sm += t[p];
        return sm;
    }

    int get_seg(int l, int r) {
        return get(r) - get(l - 1);
    }
};

void solve() {
    string s; cin >> s;
    int n = s.size();
    vector<int> arr(s.size());
    for (int i = 0; i < n; i++) arr[i] = (s[i] - 'a' + 1);
    string nww = ".";
    for (int i = 0; i < s.size(); i++) {
        nww += s[i];
        nww += '.';
    }
    auto result = manacher(nww);

    sufarr sf(n, arr);
    vector<int> order(n), pos = sf.cl;
    // for (auto &u : pos) cout << u << ' ';
    // cout << '\n';
    for (int i = 0; i < n; i++) order[sf.cl[i]] = i;
    polyhash pl(n, arr);
    vector<int> lcp(n - 1);
    for (int i = 0; i < n - 1; i++) {
        lcp[i] = pl.find_lcp(order[i], order[i + 1]);
    }
    ll ans = 0;
    {
        fenwick fw(n + 10);
        vector<vector<int>> turnoff(n + 1), turnon_gr(n + 1);
        for (int i = 1; i < sz(nww); i += 2) {
            int ml = result[i] / 2;
            turnoff[ml / 2 + 1].pb(pos[i / 2]);
        }
        for (int i = 0; i < n - 1; i++) {
            turnon_gr[lcp[i]].pb(i);
        }
        for (int i = 0; i < n; i++) fw.upd(i + 1, 1);
        set<pair<int, int>> segs;
        vector<int> CNT(n + 1, 0);
        CNT[n] = 1;
        int index_max = n;
        segs.insert({0, n});
        for (int len = 0; len <= n; len++) {
            for (int el : turnoff[len]) {
                fw.upd(el + 1, -1);
                auto rs =*(--segs.lower_bound({el + 1, -1}));
                CNT[rs.second]--;
                segs.erase(rs);
                rs.second--;
                CNT[rs.second]++;
                segs.insert(rs);
            }
            for (int el : turnon_gr[len]) {
                auto it = --segs.lower_bound({el + 1, -1});
                int L = (*it).first; it++; int R = (it == segs.end() ? n - 1 : (*it).first - 1); it--;
                CNT[(*it).second]--;
                segs.erase(it);
                int s1 = fw.get_seg(L + 1, el + 1), s2 = fw.get_seg(el + 2, R + 1);
                CNT[s1]++;
                CNT[s2]++;
                segs.insert({L, s1});
                segs.insert({el + 1, s2});
            }
            while (CNT[index_max] == 0) index_max--;
           // cout << 2 * len + 1 << ' ' << index_max << '\n';
            ans = max(ans, index_max * 1ll * (2 * len + 1));
        }
    }
    {
        fenwick fw(n + 10);
        vector<vector<int>> turnoff(n + 1), turnon_gr(n + 1);
        for (int i = 2; i < sz(nww) - 1; i += 2) {
            int ml = result[i] / 2;
            //cout << ml / 2 + 1 << '\n';
            turnoff[ml / 2 + 1].pb(pos[i / 2]);
        }
        for (int i = 0; i < n - 1; i++) {
            turnon_gr[lcp[i]].pb(i);
        }
        for (int i = 1; i < n; i++) {
            //cout << pos[i] << ' ';
            fw.upd(pos[i] + 1, 1);
        }
        //cout << " ltwfwf\n";
        set<pair<int, int>> segs;
        vector<int> CNT(n + 1, 0);
        CNT[n - 1] = 1;
        int index_max = n - 1;
        segs.insert({0, n - 1});
        for (int len = 1; len <= n; len++) {
            for (int el : turnoff[len]) {
                //cout << "chng\n";
                fw.upd(el + 1, -1);
                auto rs =*(--segs.lower_bound({el + 1, -1}));
                CNT[rs.second]--;
                segs.erase(rs);
                rs.second--;
                CNT[rs.second]++;
                segs.insert(rs);
            }
            for (int el : turnon_gr[len - 1]) {
                //cout << "fuck " << el << '\n';
                auto it = --segs.lower_bound({el + 1, -1});
                int L = (*it).first; it++; int R = (it == segs.end() ? n - 1 : (*it).first - 1); it--;
                //cout << L << ' ' << R << '\n';
                CNT[(*it).second]--;
                segs.erase(it);
                int s1 = fw.get_seg(L + 1, el + 1), s2 = fw.get_seg(el + 2, R + 1);
                //cout << s1 << ' ' << s2 << '\n';
                CNT[s1]++;
                CNT[s2]++;
                segs.insert({L, s1});
                segs.insert({el + 1, s2});
            }
            while (CNT[index_max] == 0) index_max--;
            //cout << index_max << ' ' << 2 * len << '\n';
            ans = max(ans, index_max * 1ll * (2 * len));
        }
    }
    cout << ans << '\n';
}

signed main() {
    int tt = 1;
    #ifdef LOCAL 
        freopen("in.txt", "r", stdin);
        freopen("out.txt", "w", stdout);
        cin >> tt;
    #else
        ios::sync_with_stdio(false); 
        cin.tie(0); cout.tie(0);
    #endif

    while (tt--) {
        solve();
    }

    return 0;
}