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

using namespace std;

const int BASE = 89;
const uint32_t MOD = (uint32_t) 1e9 + 7;

uint32_t add(uint32_t a, uint32_t b) {
    return (a + b) % MOD;
}

uint32_t sub(uint32_t a, uint32_t b) {
    return ((a - b) + MOD) % MOD;
}

uint32_t mul(uint32_t a, uint32_t b) {
    return ((long long)a * (long long)b) % MOD;
}

vector<uint32_t> get_straight_hash_codes(string &s, vector<uint32_t> pows) {
    vector<uint32_t> h;
    h.resize(s.size());
    h[0] = s[0];
    for (int i = 1; i < s.size(); ++i) {
        h[i] = add(h[i - 1],
                   mul(s[i], pows[i]));
    }
    return h;
}

vector<uint32_t> get_reverse_hash_codes(string &s, vector<uint32_t> pows) {
    vector<uint32_t> h;
    h.resize(s.size());
    h[s.size() - 1] = s[s.size() - 1];
    for (int i = s.size() - 2; i >= 0; --i) {
        h[i] = add(h[i + 1],
                   mul(s[i], pows[s.size() - 1 - i]));
    }
    return h;
}

vector<uint32_t> get_pows(int sz) {
    vector<uint32_t> pows;
    pows.resize(sz);
    pows[0] = 1;
    for (int i = 1; i < sz; ++i) {
        pows[i] = mul(pows[i-1], BASE);
    }
    return pows;
}

void find_palindromes(string &s, int *res, int sz) {
    vector<uint32_t> pows = get_pows(sz);
    vector<uint32_t> sh = get_straight_hash_codes(s, pows);
    vector<uint32_t> rh = get_reverse_hash_codes(s, pows);
    for (int i = 0; i < sz; ++i) {
        int max_len = min(i, sz - i - 1) + 1;
        int min_len = 0;
        while (min_len != max_len - 1) {
            int len = (max_len + min_len) / 2;

            uint32_t l = sub(sh[i], (i - len <= 0) ? 0 : sh[i - len - 1]);
            uint32_t r = sub(rh[i], (i + len >= sz - 1) ? 0 : rh[i + len + 1]);

            int p1 = i - len;
            int p2 = sz - 1 - i - len;
            if (p1 < p2) {
                l = mul(l, pows[p2 - p1]);
            } else {
                r = mul(r, pows[p1 - p2]);
            }

            if (l == r) {
                min_len = len;
            } else {
                max_len = len;
            }
        }

        res[i] = 2 * min_len + 1;
    }
}

int main() {
    string s;
    cin >> s;
    transform(begin(s), end(s), begin(s), ::tolower);
    int sz = s.size();
    int *res = new int[sz];
    find_palindromes(s, res, sz);
    for (int i = 0; i < sz; ++i) {
        cout << res[i] << " ";
    }
    return 0;
}