#include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
using vi = vector<i64>;
using vvi = vector<vi>;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());

i64 modpow(i64 a, i64 n, i64 mod) {
    if (n == 0) return 1;
    if (n % 2 == 0) {
        i64 t = modpow(a, n / 2, mod);
        return t * t % mod;
    }
    return a * modpow(a, n - 1, mod) % mod;
}

i64 modinv(i64 a, i64 mod) {
    return modpow(a, mod - 2, mod);
}

bool is_prime(i64 n, int k = 50) {
    if (n == 2) return true;
    if (n % 2 == 0 || n < 2) return false;
    i64 d = n - 1;
    while (d % 2 == 0) {
        d /= 2;
    }
    for (int i = 0; i < k; i++) {
        i64 a = rnd() % (n - 2) + 1;
        i64 t = d;
        i64 y = modpow(a, t, n);
        while (t != n - 1 && y != 1 && y != n - 1) {
            y = modpow(y, 2, n);
            t *= 2;
        }
        if (y != n - 1 && t % 2 == 0) {
            return false;
        }
    }
    return true;
}

i64 gen_prime() {
    while (1) {
        i64 d = rnd() & ((i64(1) << 31) - 1);
        d |= 1;
        if (is_prime(d)) {
            return d;
        }
    }
}

struct RollingHash {
    vi hash;
    vi pows;
    i64 p, m;
    RollingHash(string s, i64 p = gen_prime(), i64 m = gen_prime()) : hash(s.size() + 1), pows(s.size() + 1), p(p), m(m) {
        hash[0] = 1;
        pows[0] = 1;
        for (int i = 0; i < s.size(); i++) {
            hash[i + 1] = (hash[i] * p % m + s[i]) % m;
            pows[i + 1] = pows[i] * p % m;
        }
    }

    // [l, r)
    i64 encode(int l, int r) {
        return ((hash[r] - hash[l] * pows[r - l] % m) % m + m) % m;
    }

    bool eq(int l0, int r0, int l1, int r1) {
        return encode(l0, r0) == encode(l1, r1);
    }
};

vi manacher(string s) {
    int n = s.size();
    vi ret(n);
    for (int i = 0, j = 0; i < n;) {
        while (i - j >= 0 && i + j < n && s[i - j] == s[i + j]) j++;
        ret[i] = j;
        int k = 1;
        while (i - k >= 0 && i + k < n && k + ret[i - k] < j) {
            ret[i + k] = ret[i - k];
            k++;
        }
        i += k;
        j -= k;
    }
    return ret;
}

int main() {
    string s;
    cin >> s;
    string t = "$";
    for (char c: s) {
        t += c;
        t += '$';
    }
    vi m = manacher(t);
    int maxlen = *max_element(m.begin(), m.end()) - 1;
    if (maxlen == s.size()) {
        cout << maxlen - 1 << endl;
    }

    if (s.size() < 4) {
        cout << maxlen << endl;
        return 0;
    }

    i64 p = gen_prime(), mm = gen_prime();
    RollingHash rh(s, p, mm);
    string s2(s);
    reverse(s2.begin(), s2.end());
    RollingHash rh2(s2, p, mm);

    int n = s.size();

    for (int i = 1; i < n - 1; i++) {
        // A ~ [i, i + 1] ~ Bと分解して、AとBが最大どれだけ一致するかを見る
        int l = 0, r = min(i, n - i - 2) + 1;

        auto ok = [&](int m) {
            return rh.encode(i + 2, i + 2 + m) == rh2.encode(n - i, n - i + m);
        };

        while (l < r - 1) {
            int m = (l + r) / 2;
            if (ok(m)) {
                l = m;
            } else {
                r = m;
            }
        }
        maxlen = max(maxlen, 2 * l + 1);
    }

    cout << maxlen << endl;
}