#include <bits/stdc++.h>
const int N = 1e5 + 5;
int n, count[26][N];
unsigned long long hashP[N], powP[N], hashQ[N], powQ[N];
bool can[N][17];
long long pre[N], ans, exact[N][26];
char s[N];
inline unsigned long long queryP(int l, int len) {
  return hashP[l + len - 1] - hashP[l - 1] * powP[len];
}
inline unsigned long long queryQ(int l, int len) {
  return hashQ[l + len - 1] - hashQ[l - 1] * powQ[len];
}
inline int lcp(int a, int b) {
  int l = 1, r = n - std ::max(a, b) + 1, res = 0;
  while (l <= r) {
    int mid = l + r >> 1;
    if (hashP[a + mid - 1] - hashP[a - 1] * powP[mid] ==
            hashP[b + mid - 1] - hashP[b - 1] * powP[mid] &&
        hashQ[a + mid - 1] - hashQ[a - 1] * powQ[mid] ==
            hashQ[b + mid - 1] - hashQ[b - 1] * powQ[mid])
      res = mid, l = mid + 1;
    else
      r = mid - 1;
  }
  return res;
}
void solve(int l, int len, int k) {
  if (!k) {
    for (int i = 0; i < 26; ++i) ++exact[l][i];
    return;
  }
  int j = len >> 1, a = l, b = l + j + 1;
  if (can[a][k - 1] && can[b][k - 1])
    if (queryP(a, j) == queryP(b, j) && queryQ(a, j) == queryQ(b, j))
      for (int i = 0; i < 26; ++i)
        if (!(count[i][a + j - 1] - count[i][a - 1]))
          exact[a + j][i] += (long long)len * len;
  int s0 = lcp(a, b);
  if (s0 >= j) return;
  int s1 = lcp(a + s0 + 1, b + s0 + 1);
  if (s0 + s1 + 1 < j) return;
  int c = s[a + j] - 'a';
  if (can[a][k - 1] && !(count[c][a + j - 1] - count[c][a - 1]))
    exact[b + s0][s[a + s0] - 'a'] += (long long)len * len;
  if (can[b][k - 1] && !(count[c][b + j - 1] - count[c][b - 1]))
    exact[a + s0][s[b + s0] - 'a'] += (long long)len * len;
}
int main() {
  scanf("%s", s + 1), n = strlen(s + 1);
  for (int c = 0; c < 26; ++c)
    for (int i = 1, sum = 0; i <= n; ++i)
      count[c][i] = sum += (s[i] - 'a' == c);
  for (int i = 1; i <= n; ++i) hashP[i] = 31ull * hashP[i - 1] + s[i] - 'a' + 1;
  powP[0] = 1;
  for (int i = 1; i <= n; ++i) powP[i] = 31ull * powP[i - 1];
  for (int i = 1; i <= n; ++i) hashQ[i] = 29ull * hashQ[i - 1] + s[i] - 'a' + 1;
  powQ[0] = 1;
  for (int i = 1; i <= n; ++i) powQ[i] = 29ull * powQ[i - 1];
  long long res = 0;
  for (int k = 0, len = 1; k <= 16; ++k, len = len * 2 + 1)
    for (int i = 1; i + len - 1 <= n; ++i) {
      if (!k) {
        can[i][k] = true;
        ++pre[i], --pre[i + 1];
        ++res;
        continue;
      }
      int j = len >> 1;
      if (!can[i][k - 1] || !can[i + j + 1][k - 1]) continue;
      if (queryP(i, j) != queryP(i + j + 1, j)) continue;
      if (queryQ(i, j) != queryQ(i + j + 1, j)) continue;
      if (count[s[i + j] - 'a'][i + len - 1] - count[s[i + j] - 'a'][i - 1] > 1)
        continue;
      pre[i] += (long long)len * len, pre[i + len] -= (long long)len * len;
      can[i][k] = true, res += (long long)len * len;
    }
  for (int i = 1; i <= n; ++i) pre[i] += pre[i - 1];
  ans = res;
  for (int k = 0, len = 1; k <= 16; ++k, len = len * 2 + 1)
    for (int i = 1; i + len - 1 <= n; ++i) solve(i, len, k);
  for (int i = 1; i <= n; ++i)
    for (int c = 0; c < 26; ++c)
      ans = std ::max(ans, res - pre[i] + exact[i][c]);
  printf("%I64d\n", ans);
}
