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

#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){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];
                }
            }
        }
        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;
        }
        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];
    };
}


#include<bits/stdc++.h>
using namespace std;
int main(){
	cin.tie(nullptr)->sync_with_stdio(false);
	string s;
	cin>>s;
	auto border=exodus::kmp_algo(s);
	for(auto x:border)
		printf("%d ",x);
	printf("\n");
	return 0;
}