#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;
	}
};

auto main() ->int32_t {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);

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

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

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

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

	debug(end);
	debug(adj);

	auto dfs = [&](auto && dfs, int u) ->void {
		for (const auto & v : adj[u]) {
			dfs(dfs, v);
			f[u] += f[v];
		}
		chmax(ans, 1LL * f[u] * pam.len(u) * pam.len(u));
	};
	dfs(dfs, 0);

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

	return 0;
}

answer.code: In lambda function:
answer.code:134:22: error: no matching function for call to ‘chmax(i64&, long long int)’
  134 |                 chmax(ans, 1LL * f[u] * pam.len(u) * pam.len(u));
      |                 ~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
answer.code:17:16: note: candidate: ‘template<class T> constexpr void chmax(T&, T)’
   17 | constexpr void chmax(T& x, T y) {
      |                ^~~~~
answer.code:17:16: note:   template argument deduction/substitution failed:
answer.code:134:22: note:   deduced conflicting types for parameter ‘T’ (‘long int’ and ‘long long int’)
  134 |                 chmax(ans, 1LL * f[u] * pam.len(u) * pam.len(u));
      |                 ~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~