#include <cassert>
#include <chrono>
#include <queue>
#include <string>
#include <random>
#include <vector>

#include<string>
namespace exodus{
    namespace internal{
        const std::basic_string<char>Alpha{'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
        const std::basic_string<char>alpha{'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
        const std::basic_string<char>digit{'0','1','2','3','4','5','6','7','8','9'};
    }
}


namespace exodus{
    using internal::Alpha;
    using internal::alpha;
    using internal::digit;
    std::vector<int> kmp_algo(const std::string& s){
        int n=s.size();
        std::vector<int>fail(n);
        fail[0]=-1;
        for(int i=1,j=-1;i<n;i++){
            while(j!=-1&&s[i]!=s[j+1]) j=fail[j];
            if(s[i]==s[j+1]) ++j;
            fail[i]=j;
        }
        for(int i=0;i<n;i++)
            ++fail[i];
        return fail;
    }
    struct aho_corasick_automaton{
    public:
        struct node{
            std::vector<int>son;
            int fail;
            node(){}
            explicit node(int _sigma_size){fail=0;son.resize(_sigma_size,0);}
        };
        aho_corasick_automaton(){}
        explicit aho_corasick_automaton(int _limit_size,std::basic_string<char>_sigma){
            sigma_size=0;
            for(auto c:_sigma)
                trans[c]=sigma_size++;
            limit_size=_limit_size;
            nd.resize(limit_size,node(sigma_size));
            endpos.resize(limit_size);
            total_size=1;
            string_cnt=0;
        }
        void insert(const std::string& s){
            int u=0;
            for(auto c:s){
                if(nd[u].son[trans[c]]==0)
                    nd[u].son[trans[c]]=total_size++,assert(total_size<=limit_size);
                u=nd[u].son[trans[c]];
            }
            endpos[string_cnt]=u;
            string_cnt++;
        }
        void build(){
            std::queue<int>q;
            nd[0].fail=0;
            for(int i=0;i<sigma_size;i++)
                if(nd[0].son[i]!=0)
                    q.emplace(nd[0].son[i]),nd[nd[0].son[i]].fail=0;
            while(!q.empty()){
                int u=q.front();
                q.pop();
                for(int i=0;i<sigma_size;i++){
                    if(nd[u].son[i]!=0)
                        nd[nd[u].son[i]].fail=nd[nd[u].fail].son[i],q.emplace(nd[u].son[i]);
                    else
                        nd[u].son[i]=nd[nd[u].fail].son[i];
                }
            }
        }
        int locate(const std::string& s){
            int u=0;
            for(auto c:s){
                u=nd[u].son[trans[c]];
            }
            return u;
        }
        std::vector<int>locate_path(const std::string& s){
            int u=0;
            std::vector<int>res{u};
            for(auto c:s){
                u=nd[u].son[trans[c]];
                res.emplace_back(u);
            }
            return res;
        }
        std::vector<int> get_fail(){
            std::vector<int>result(total_size);
            for(int i=0;i<total_size;i++)
                result[i]=nd[i].fail;
            return result;
        }
        const std::vector<node> &get_trie(){
            return nd;
        }
        std::vector<int> get_endpos(){
            return endpos;
        }
        int get_size(){
            return total_size;
        }
        int val(char c){
            return trans[c];
        }
    private:
        int sigma_size,total_size,limit_size,string_cnt;
        std::vector<node>nd;
        std::vector<int>endpos;
        int trans[256];
    };
    
    template<typename T>
    std::vector<int> manacher_algo(const std::basic_string<T> &str){
        int len=str.size();
        std::vector<int>r(2*len+1);
        for(int i=0,j=0,k;i<=2*len;i+=k,j-=k){
            for(;0<i-j&&i+j<2*len&&(!((i+j+1)&1)||str[(i-j-1)>>1]==str[(i+j+1)>>1]);++j);
            r[i]=j;
            for(k=1;k<j&&k+r[i-k]<j;++k)r[i+k]=r[i-k];
        }
        return r;
    }
    
    template<typename T>
    std::vector<int> z_algo(const std::basic_string<T> & str){
        int len=str.size();
        if(!len)return {};
        std::vector<int>z(len,0);
        z[0]=0;
        for(int i=1,j=0;i<len;i++){
            int &k=z[i];
            k=(j+z[j]<=i)?0:std::min(j+z[j]-i,z[i-j]);
            while(i+k<len&&str[k]==str[i+k])k++;
            if(j+z[j]<i+z[i])j=i;
        }
        z[0]=len;
        return z;
    }
}


#include<bits/stdc++.h>
using namespace std;

template<typename T,typename U>ostream &operator<<(ostream &os,const pair<T,U>&x){return os<<"("<<x.first<<","<<x.second<< ")"; };
template<typename T>ostream &operator<<(ostream &os,const vector<T> &as){const int sz=as.size();os<<"[";for(int i=0;i<sz;++i){if(i>=256){os<<",...";break;}if(i>0){os<<",";}os<<as[i];}return os<<"]";}

int main(){
	cin.tie(nullptr)->sync_with_stdio(false);
	string s;
	cin>>s;
	auto z=exodus::z_algo(s);
    z[0]=0;
	for(auto x:z)
		cout<<x<<' ';
	cout<<'\n';
	return 0;
}