#include<bits/stdc++.h>

#define MAXN 100005

#define INF 0x3f3f3f3f

using namespace std;

struct SGT{

	int rt,size;

	int ls[MAXN*2],rs[MAXN*2],lazy[2][MAXN*2];

	void Build(int &u,int l,int r){

		u=++size;

		lazy[0][u]=lazy[1][u]=INF;

		if(l==r) return;

		int mid=(l+r)/2;

		Build(ls[u],l,mid);

		Build(rs[u],mid+1,r);

	}

	void Modify(int u,int l,int r,int al,int ar,int val,int k){

		if(al<=l&&r<=ar) return (void)(lazy[k][u]=min(lazy[k][u],val));

		int mid=(l+r)/2;

		if(al<=mid) Modify(ls[u],l,mid,al,ar,val,k);

		if(mid<ar) Modify(rs[u],mid+1,r,al,ar,val,k);

	}

	void Answer(int u,int l,int r,int minlazy0,int minlazy1){

		minlazy0=min(minlazy0,lazy[0][u]);

		minlazy1=min(minlazy1,lazy[1][u]);

		if(l==r){

			printf("%d\n",min(minlazy0,minlazy1-l+1));

			return;

		}

		int mid=(l+r)/2;

		Answer(ls[u],l,mid,minlazy0,minlazy1);

		Answer(rs[u],mid+1,r,minlazy0,minlazy1);

	}

}DT;

struct SAM{

	int size;

	int maxs[MAXN*3],trans[MAXN*3][26],parent[MAXN*3],minr[MAXN*3],right[MAXN*3];

	int Newnode(int a,int b){

		++size; maxs[size]=a; minr[size]=INF;

		memcpy(trans[size],trans[b],sizeof(trans[b]));

		return size;

	}

	int Extend(int last,int x){

		static int p,np,q,nq;

		p=last; np=Newnode(maxs[p]+1,0);

		for(;p&&!trans[p][x];p=parent[p]) trans[p][x]=np;

		if(!p) parent[np]=1;

		else{

			q=trans[p][x];

			if(maxs[p]+1!=maxs[q]){

				nq=Newnode(maxs[p]+1,q);

				parent[nq]=parent[q];

				parent[q]=parent[np]=nq;

				for(;p&&trans[p][x]==q;p=parent[p]) trans[p][x]=nq;

			}

			else parent[np]=q;

		}

		return np;

	}

	void Build(char *S){

		static int p=1,last,len,tmp[MAXN],order[MAXN*3];

		memset(trans[0],0,sizeof(trans[0]));

		size=0; last=Newnode(0,0); len=strlen(S);

		for(int i=0;i<len;i++) last=Extend(last,S[i]-'a');

		for(int i=0;i<len;i++) p=trans[p][S[i]-'a'],minr[p]=i,right[p]=1;

		for(int i=1;i<=size;i++) tmp[maxs[i]]++;

		for(int i=1;i<=len;i++) tmp[i]+=tmp[i-1];

		for(int i=1;i<=size;i++) order[tmp[maxs[i]]--]=i;

		for(int i=size;i;i--){

			p=order[i];

			minr[parent[p]]=min(minr[parent[p]],minr[p]);

			right[parent[p]]+=right[p];

		}

	}

	void Solve(int len){

		for(int i=1,l,r;i<=size;i++) if(right[i]==1){

			l=minr[i]-maxs[i]+1; r=minr[i]-maxs[parent[i]];

			DT.Modify(DT.rt,0,len-1,r,minr[i],maxs[parent[i]]+1,0);

			DT.Modify(DT.rt,0,len-1,l,r,minr[i],1);

		}

	}

}SUF;

int main(){

	static char S[MAXN];

	scanf("%s",S);

	int len=strlen(S);

	DT.Build(DT.rt,0,len-1);

	SUF.Build(S);

	SUF.Solve(len);

	DT.Answer(DT.rt,0,len-1,INF,INF);

	return 0;

}