#include "bits/stdc++.h"

using namespace std;

const double eps = 1e-;

#define reg register

#define lowbit(x) x&-x

#define pll pair<ll,ll>

#define pii pair<int,int>

#define fi first

#define se second

#define makp make_pair

int dcmp(double x) {

    if (fabs(x) < eps) return ;

    return (x > ) ?  : -;

}

typedef long long ll;

typedef unsigned long long ull;

const ull hash1 = ;

const ull hash2 = ;

const int N =  + ;

const int M =  + ;

const int inf = 0x3f3f3f3f;

const ll mod = ;

ll ret[N];

ull ha[N], pp[N];

ull getha(int l, int r) {

    if (l == ) return ha[r];

    return ha[r] - ha[l - ] * pp[r - l + ];

}

bool check(int l, int r) {

    int len = r - l + ;

    int mid = (l + r) >> ;

    if (len & ) return getha(l, mid) == getha(mid, r);

    else return getha(l, mid) == getha(mid + , r);

}

struct Palindromic_Tree {

    int nxt[N][], fail[N], cnt[N];

    int num[N], len[N], s[N], id[N];

    int last, n, p;

    int newnode(int l) {

        memset(nxt[p], , sizeof(nxt[p]));

        cnt[p] = num[p] = ;

        len[p] = l;

        return p++;

    }

    void init() {

        p = ;

        newnode(), newnode(-);

        last = n = ;

        s[] = -;

        fail[] = ;

    }

    int get_fail(int x) {

        while (s[n - len[x] - ] != s[n]) x = fail[x];

        return x;

    }

    void add(int c) {

        c -= 'a';

        s[++n] = c;

        int cur = get_fail(last);

        if (!nxt[cur][c]) {

            int now = newnode(len[cur] + );

            fail[now] = nxt[get_fail(fail[cur])][c];

            nxt[cur][c] = now;

            num[now] = num[fail[now]] + ;

        }

        last = nxt[cur][c];

        cnt[last]++, id[last] = n;

    }

    ll Count() {

        for (int i = p - ; i >= ; i--) cnt[fail[i]] += cnt[i];

        for (int i = ; i < p; i++) {

            ///cout << id[i] - len[i] << " " << id[i] - 1 << endl;

            if (check(id[i] - len[i], id[i] - 1)) {

                ret[len[i]] += cnt[i];

            }

        }

        return ;

    }

} pam;

char str[N];

int main() {

    pp[] = ;

    for (int i = ; i < N; i++) {

        pp[i] = hash1 * pp[i - ];

    }

    while (~scanf("%s", str)) {

        memset(ret, , sizeof(ret));

        pam.init();

        int len = strlen(str);

        ha[] = str[];

        for (int i = ; i < len; i++) {

            pam.add(str[i]);

        }

        for (int i = ; i < len; i++) {

            ha[i] = ha[i - ] * hash1 + str[i];

        }

        pam.Count();

        printf("%lld", ret[]);

        for (int i = ; i <= len; i++) {

            printf(" %lld", ret[i]);

        }

        printf("\n");

    }

    return ;

}