#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define X first
#define Y second
#define ALL(v) v.begin(), v.end()
#define pb push_back
#define SZ(a) ((int)a.size())

const int N = 50005;
const int CNUM = 26;
const int INF = 1e9;

struct exSAM {
    int milen[N * 2], len[N * 2], link[N * 2];  
    int next[N * 2][CNUM], tot;
    int lenSorted[N * 2];
    int cnt[N * 2];
    int newnode() {
        fill_n(next[tot], CNUM, 0);
        len[tot] = cnt[tot] = link[tot] = 0;
        return tot++;
    }
    void init() { tot = 0, newnode(), link[0] = -1; }
    int insertSAM(int last, int c) {
        int cur = next[last][c];
        len[cur] = len[last] + 1;
        int p = link[last];
        while (p != -1 && !next[p][c])
            next[p][c] = cur, p = link[p];
        if (p == -1) return link[cur] = 0, cur;
        int q = next[p][c];
        if (len[p] + 1 == len[q]) return link[cur] = q, cur;
        int clone = newnode();
        for (int i = 0; i < CNUM; ++i)
            next[clone][i] = len[next[q][i]] ? next[q][i] : 0;
        len[clone] = len[p] + 1;
        while (p != -1 && next[p][c] == q)
            next[p][c] = clone, p = link[p];
        link[link[cur] = clone] = link[q];
        link[q] = clone;
        return cur;
    }
    void insert(const string &s) {
        int cur = 0;
        for (auto ch : s) {
            int &nxt = next[cur][int(ch - 'a')];
            if (!nxt) nxt = newnode();
            cnt[cur = nxt] += 1;
        }
    }
    void build() {
        queue<int> q;
        q.push(0);
        while (!q.empty()) {
            int cur = q.front();
            q.pop();
            for (int i = 0; i < CNUM; ++i)
                if (next[cur][i])
                    q.push(insertSAM(cur, i));
        }
        vector<int> lc(tot);
        for (int i = 1; i < tot; ++i) ++lc[len[i]];
        partial_sum(ALL(lc), lc.begin());
        for (int i = 1; i < tot; ++i) lenSorted[--lc[len[i]]] = i;
    }
    void solve() {
        for (int i = tot - 2; i >= 0; --i) {
            cnt[link[lenSorted[i]]] += cnt[lenSorted[i]];
        }
        fill_n(milen, tot, INF);
        for (int j = 0; j < CNUM; ++j)
            if (next[0][j])
                milen[next[0][j]] = 1;
        for (int i = 0; i <= tot - 2; ++i) {
            for (int j = 0; j < CNUM; ++j)
                if (next[lenSorted[i]][j]) {
                    milen[next[lenSorted[i]][j]] = min(milen[next[lenSorted[i]][j]], milen[lenSorted[i]] + 1);
                }
        }
    }
} sam;

vector<int> G[N * 2], buk[N * 2];
vector<int> seg[N * 4];
pii itv[N * 2], ans[N];
int in[N * 2], out[N * 2], pl[N * 2], dft;

void dfs(int u) {
    in[u] = ++dft, pl[dft] = u;
    for (int i : G[u])
        dfs(i);
    out[u] = dft;
}

void build(int l, int r, int rt) {
    for (int i = l; i <= r; ++i)
        for (int j : buk[pl[i]])
            seg[rt].pb(j);
    seg[rt].pb(INF);
    sort(ALL(seg[rt]));
    if (l == r) return;
    int mid = (l + r) >> 1;
    build(l, mid, rt << 1), build(mid + 1, r, rt << 1 | 1);
}

int lb(int L, int R, int l, int r, int rt, int v) {
    if (L <= l && R >= r) {
        return *lower_bound(ALL(seg[rt]), v);
    }
    int mid = (l + r) >> 1;
    if (R <= mid) return lb(L, R, l, mid, rt << 1, v);
    if (L > mid) return lb(L, R, mid + 1, r, rt << 1 | 1, v);
    return min(lb(L, R, l, mid, rt << 1, v), lb(L, R, mid + 1, r, rt << 1 | 1, v));
}

int sz = 0;

void solve(int u) {
    int l = itv[u].X, r = itv[u].Y + 1;
    
    auto jump = [&](int k) {
        int res = 0;
        auto p = lb(in[u], out[u], 1, sz, 1, 0);
        while (p < INF) {
            ++res;
            p = lb(in[u], out[u], 1, sz, 1, p + k); 
        }
        return res;
    };

    if (l != 0) {
        int mx = jump(l);

        while (r - l > 1) {
            int mid = (l + r) >> 1;
            if (jump(mid) == mx) l = mid;
            else r = mid;
        }

        //cerr << "solve " << u << ": " << mx << " " << l << ", cnt = " << sam.cnt[u] << "\n";
        ans[sam.cnt[u]] = max(ans[sam.cnt[u]], pii(mx, l));
    }

}

int main() {
    ios::sync_with_stdio(0), cin.tie(0);
    string s;
    cin >> s;
    sam.init();
    sam.insert(s);
    sam.build();
    sam.solve();
    /*for (int i = 1; i < sam.tot; ++i) {
      cerr << sam.cnt[i] << " ";
      }
      cerr << endl;
      for (int i = 1; i < sam.tot; ++i) {
      cerr << sam.link[i] << " ";
      }
      cerr << endl;
      for (int i = 1; i < sam.tot; ++i) {
      cerr << "[" << sam.milen[i] << ", " << sam.len[i] << "] ";
      }
      cerr << endl;*/
    for (int i = 1; i < sam.tot; ++i) {
        itv[i] = pii(sam.milen[i], sam.len[i]);
        G[sam.link[i]].pb(i);
    }
    dfs(0);
    int cur = 0;
    for (int i = 0; i < SZ(s); ++i) {
        cur = sam.next[cur][int(s[i] - 'a')];
        buk[cur].pb(i);
    }
    sz = sam.tot;
    build(1, sz, 1);
    for (int i = 1; i < sam.tot; ++i)
        solve(i);
    for (int i = 1; i <= SZ(s); ++i)
        cout << ans[i].Y << " \n"[i == SZ(s)];
}