#include <bits/stdc++.h>
void init (void) {
	std::ios::sync_with_stdio(false); std::cin.tie(nullptr); std::cout.tie(nullptr);
}
void Print (std::vector<int> a, char c = '\n') {
	std::cerr << '{'; if (!a.empty()) std::cerr << a[0];
	for (int i = 1; i < (int)a.size(); i++) std::cerr << ", " << a[i];
	std::cerr << '}' << c;
}
void Discretization (std::vector<int> &a) {
	auto b = a; std::sort(b.begin(), b.end());
	b.resize(std::unique(b.begin(), b.end()) - b.begin());
	for (int &x: a) x = std::lower_bound(b.begin(), b.end(), x) - b.begin();
}
struct KMP {
	int n; std::vector<int> pi;
	KMP (std::vector<int> s = std::vector<int>()) {
		n = s.size(); pi = std::vector<int>(n, -1);
		for (int i = 1, j = -1; i < n; i++) {
			while (~j and s[i] != s[j + 1]) j = pi[j];
			pi[i] = (j += s[i] == s[j + 1]);
		}
	}
};
struct Zfunction {
	int n; std::vector<int> z;
	Zfunction (std::vector<int> s = std::vector<int>()) {
		n = s.size(); z = std::vector<int>(n, 0);
		for (int i = 1, l = 0, r = 1; i < n; i++) {
			if (i < r) z[i] = std::min(z[i - l], r - i);
			while (i + z[i] < n and s[z[i]] == s[i + z[i]]) z[i]++;
			if (i + z[i] > r) l = i, r = i + z[i];
		}
	}
};
struct SuffixArray {
	int n; std::vector<int> sa, rk, h; std::vector<std::vector<int>> st;
	SuffixArray (std::vector<int> s = std::vector<int>()) {
		n = s.size(); sa = rk = h = std::vector<int>(n);
		int m = *std::max_element(s.begin(), s.end()) + 1;
		std::vector<int> x(n << 1, -1), y(n << 1, -1), c(m, 0);
		for (int i = 0; i < n; i++) ++c[x[i] = s[i]], y[i] = i;
		for (int i = 1; i < m; i++) c[i] += c[i - 1];
		for (int i = n - 1; ~i; i--) sa[--c[x[y[i]]]] = y[i];
		for (int k = 1; k <= n; k <<= 1) {
			for (int i = n - k; i < n; i++) y[i - n + k] = i;
			for (int i = 0, j = k; i < n; i++) if (sa[i] >= k) y[j++] = sa[i] - k;
			c = std::vector<int>(m, 0);
			for (int i = 0; i < n; i++) ++c[x[i]];
			for (int i = 1; i < m; i++) c[i] += c[i - 1];
			for (int i = n - 1; ~i; i--) sa[--c[x[y[i]]]] = y[i];
			std::swap(x, y); x[sa[0]] = m = 0;
			for (int i = 1; i < n; i++) x[sa[i]] = (m += y[sa[i]] != y[sa[i - 1]] or y[sa[i] + k] != y[sa[i - 1] + k]);
			if (++m == n) break;
		}
		for (int i = 0; i < n; i++) rk[sa[i]] = i;
		for (int i = 0, k = 0; i < n; i++) if (rk[i]) {
			if (k) k--;
			for (int j = sa[rk[i] - 1]; i + k < n and j + k < n and s[i + k] == s[j + k]; ) k++;
			h[rk[i]] = k;
		}
		st = std::vector<std::vector<int>>(std::__lg(n) + 1, h);
		for (int i = 1; i <= std::__lg(n); i++)
			for (int j = 0; j + (1 << i) <= n; j++)
				st[i][j] = std::min(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
	}
	int lcp (int i, int j) {
		if (i == j) return n - i;
		if (i == n or j == n) return 0;
		if ((i = rk[i]) > (j = rk[j])) std::swap(i, j);
		int k = std::__lg(j - i); return std::min(st[k][i + 1], st[k][j - (1 << k) + 1]);
	}
};
struct BinaryIndexedTree {
	int n; std::vector<int> t; std::vector<long long> s;
	BinaryIndexedTree (int _n = 0): n(_n) {t = std::vector<int>(n + 1); s = std::vector<long long>(n + 1);}
	void add (int l, int r, int w) {
		l = std::max(l, 0) + 1; r = std::min(r, n) + 1;
		long long wl = 1LL * w * l, wr = 1LL * w * r;
		for (int i = l; i <= n; i += i & -i) t[i] += w, s[i] += wl;
		for (int i = r; i <= n; i += i & -i) t[i] -= w, s[i] -= wr;
	}
	long long ask (int l, int r) {
		int wl = 0, wr = 0; long long w = 0;
		l = std::max(l, 0); r = std::min(r, n);
		for (int i = l; i; i -= i & -i) wl -= t[i], w += s[i];
		for (int i = r; i; i -= i & -i) wr += t[i], w -= s[i];
		return w + 1LL * (l + 1) * wl + 1LL * (r + 1) * wr;
	}
} B;
struct LinkCutTree {
	std::vector<int> col, tag, fa, len; std::vector<std::array<int, 2>> ch;
	bool isroot (int u) {return ch[fa[u]][0] != u and ch[fa[u]][1] != u;}
	void cover (int u, int w) {col[u] = tag[u] = w;}
	void pushdown (int u) {
		if (~tag[u]) {
			if (ch[u][0]) cover(ch[u][0], tag[u]);
			if (ch[u][1]) cover(ch[u][1], tag[u]);
			tag[u] = -1;
		}
	}
	int get (int u) {return ch[fa[u]][1] == u;}
	void link (int u, int v, int k) {
		if (u and ~k) ch[u][k] = v;
		if (v) fa[v] = u;
	}
	void rotate (int u) {
		int v = fa[u], w = fa[v], k = get(u);
		link(w, u, isroot(v) ? -1 : get(v)); link(v, ch[u][k ^ 1], k); link(u, v, k ^ 1);
	}
	void push (int u) {
		if (!isroot(u)) push(fa[u]);
		pushdown(u);
	}
	void splay (int u) {
		for (push(u); !isroot(u); rotate(u))
			if (!isroot(fa[u])) rotate(get(u) ^ get(fa[u]) ? u : fa[u]);
	}
	void init (int n, std::vector<int> fa, std::vector<int> len) {
		col = tag = std::vector<int>(n + 1, -1); this -> len = len;
		this -> fa = fa; ch = std::vector<std::array<int, 2>>(n + 1, {0, 0});
	}
	void access (int u, int w) {
		int v = 0;
		for (; u; ch[u][1] = v, v = u, u = fa[u]) {
			splay(u);
			if (~col[u]) B.add(col[u] - len[u] + 1, col[u] - len[fa[u]] + 1, -1);
		}
		cover(v, w); B.add(0, w + 1, 1);
	}
} T;
struct SuffixAutomaton {
	int n, tot, lst; std::vector<int> fa, len, end; std::vector<std::vector<int>> ch;
	SuffixAutomaton (std::vector<int> s = std::vector<int>()) {
		n = s.size(); tot = lst = 1; fa = len = std::vector<int>(n << 1); end = std::vector<int>(n);
		ch = std::vector<std::vector<int>>(n << 1, std::vector<int>(*std::max_element(s.begin(), s.end()) + 1));
		for (int i = 0; i < n; i++) extend(s[i], i);
		fa.resize(tot + 1); len.resize(tot + 1); ch.resize(tot + 1);
	}
	void extend (int c, int i) {
		int np = ++tot, p = lst; lst = np; len[np] = len[p] + 1; end[i] = np;
		for (; p and !ch[p][c]; p = fa[p]) ch[p][c] = np;
		if (!p) {fa[np] = 1; return;}
		int q = ch[p][c]; if (len[q] == len[p] + 1) {fa[np] = q; return;}
		int nq = ++tot; fa[nq] = fa[q]; ch[nq] = ch[q]; len[nq] = len[p] + 1; fa[np] = fa[q] = nq;
		for (; p and ch[p][c] == q; p = fa[p]) ch[p][c] = nq;
	}
	std::vector<long long> count (std::vector<std::pair<int, int>> Q) {
		int q = Q.size(); std::vector<long long> ans(q);
		std::vector<std::vector<std::pair<int, int>>> qry(n);
		for (int i = 0; i < q; i++) qry[Q[i].second].emplace_back(Q[i].first, i);
		B = BinaryIndexedTree(n); T.init(tot, fa, len);
		for (int r = 0; r < n; r++) {
			T.access(end[r], r);
			for (auto [l, i]: qry[r]) ans[i] = B.ask(l, r + 1);
		}
		return ans;
	}
};
struct Manacher {
	int n; std::vector<int> p;
	Manacher (std::vector<int> s = std::vector<int>()) {
		n = s.size(); p = std::vector<int>(2 * n + 1); s.resize(2 * n + 1);
		for (int i = n - 1; ~i; i--) s[2 * i + 1] = s[i];
		for (int i = 0; i <= 2 * n; i += 2) s[i] = -1;
		for (int i = 1, l = 0, r = 0; i <= 2 * n; i++) {
			p[i] = i <= r ? std::min(p[l + r - i], r - i) : 0;
			while (p[i] < i and i + p[i] < 2 * n and s[i - p[i] - 1] == s[i + p[i] + 1]) p[i]++;
			if (i + p[i] >= r) l = i - p[i], r = i + p[i];
		}
	}
};
struct PalindromicAutomaton {
	std::deque<int> s; int m, lstL, lstR;
	std::vector<int> fa, len; std::vector<std::vector<int>> ch;
	std::vector<int> cnt;
	PalindromicAutomaton (std::vector<int> s = std::vector<int>()) {
		m = *std::max_element(s.begin(), s.end()) + 1;
		lstL = lstR = 0; this -> s = std::deque<int>(); len = {0, -1};
		fa = {1, 0}; ch = std::vector<std::vector<int>>(2, std::vector<int>(m, 0));
		cnt = {0, 0};
		for (int c: s) extendR(c);
	}
	void extendL (int c) {
		s.push_front(c);
		auto find = [&] (int u) {
			while (len[u] + 2 > (int)s.size() or s.front() != s[len[u] + 1]) u = fa[u];
			return u;
		};
		if (!ch[lstL = find(lstL)][c]) {
			fa.emplace_back(ch[find(fa[lstL])][c]); len.emplace_back(len[lstL] + 2);
			ch.emplace_back(std::vector<int>(m, 0)); ch[lstL][c] = len.size() - 1; cnt.emplace_back(0);
		}
		if (len[lstL = ch[lstL][c]] == (int)s.size()) lstR = lstL;
		cnt[lstL]++;
	}
	void extendR (int c) {
		s.push_back(c);
		auto find = [&] (int u) {
			while (len[u] + 2 > (int)s.size() or s.back() != s.end()[- len[u] - 2]) u = fa[u];
			return u;
		};
		if (!ch[lstR = find(lstR)][c]) {
			fa.emplace_back(ch[find(fa[lstR])][c]); len.emplace_back(len[lstR] + 2);
			ch.emplace_back(std::vector<int>(m, 0)); ch[lstR][c] = len.size() - 1; cnt.emplace_back(0);
		}
		if (len[lstR = ch[lstR][c]] == (int)s.size()) lstL = lstR;
		cnt[lstR]++;
	}
	long long ans;
	std::vector<std::vector<int>> e;
	void dfs (int u) {
		for (int v: e[u]) dfs(v), cnt[u] += cnt[v];
		if (u > 1) ans = std::max(ans, 1LL * cnt[u] * len[u] * len[u]);
	}
	void solve (void) {
		ans = 0; e = std::vector<std::vector<int>>(len.size());
		for (int i = 2; i < (int)len.size(); i++) e[fa[i]].emplace_back(i);
		dfs(0); dfs(1);
		std::cout << ans << std::endl;
	}
};
signed main () {
	init();
	std::string s; std::cin >> s; int n = s.length();
	std::vector<int> a(n); for (int i = 0; i < n; i++) a[i] = s[i] - 'a'; // Discretization(a);
	PalindromicAutomaton P(a); P.solve();
	return 0;
}