#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
#include <string>

#define int long long

int add(int a, int b, int mod) {
    return (a + b) % mod;
}

int sub(int a, int b, int mod) {
    return ((a - b) % mod + mod) % mod;
}

int mull(int a, int b, int mod) {
    return (a * b) % mod;
}

std::pair<int, int>
GetHash(int l, int r, std::vector<std::pair<int, int>> &hashes, std::vector<int> &powers, std::vector<int> &powers_2,
        int m, int m_2) {
    return std::make_pair(sub(hashes[r + 1].first, mull(hashes[l].first, powers[r - l + 1], m), m),
                          sub(hashes[r + 1].second, mull(hashes[l].second, powers_2[r - l + 1], m_2), m_2));
}

int32_t main() {
    std::string b;
    std::cin >> b;
    int p = 10, m = 1000000000 + 21, m_2 = 998244353;
    std::vector<int> powers((int) b.size() + 1), powers_2((int) b.size() + 1), rev_powers(
            (int) b.size() + 1), rev_powers_2((int) b.size() + 1);
    std::vector<std::pair<int, int>> hashes((int) b.size() + 1), rev_hashes((int) b.size() + 1);
    hashes[0].first = 0;
    powers[0] = 1;
    hashes[0].second = 0;
    powers_2[0] = 1;
    rev_powers[0] = 1;
    rev_powers_2[0] = 1;

    for (int i = 0; i < (int) b.size(); ++i) {
        hashes[i + 1].first = add(mull(hashes[i].first, p, m), b[i], m);
        powers[i + 1] = mull(powers[i], p, m);
        hashes[i + 1].second = add(mull(hashes[i].second, p, m_2), b[i], m_2);
        powers_2[i + 1] = mull(powers_2[i], p, m_2);
    }
    std::reverse(b.begin(), b.end());
    for (int i = 0; i < (int) b.size(); ++i) {
        rev_hashes[i + 1].first = add(mull(rev_hashes[i].first, p, m), b[i], m);
        rev_powers[i + 1] = mull(rev_powers[i], p, m);
        rev_hashes[i + 1].second = add(mull(rev_hashes[i].second, p, m_2), b[i], m_2);
        rev_powers_2[i + 1] = mull(rev_powers_2[i], p, m_2);
    }
    int size = static_cast<int>(b.size());
    for (int i = 0; i < size; ++i) {
        int l = 0, r = std::min(i, size - i - 1) + 1;
        while (r - l > 1) {
            int current_val = (r + l + 1) / 2;
            int left_index = i - current_val, right_index = i - 1;
            int reversed_left_index = size - 1 - i - current_val, reversed_right_index = size - i - 2;
            auto a_1 = GetHash(left_index, right_index, hashes, powers, powers_2, m, m_2);
            auto a_2 = GetHash(reversed_left_index, reversed_right_index, rev_hashes, rev_powers, rev_powers_2, m, m_2);

            if (a_1 == a_2) {
                l = current_val;
            } else {
                r = current_val;
            }
        }
        std::cout << (l * 2) + 1 << " ";
    }
    return 0;
}