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

typedef pair<int,int> pii;

const int MAXN = 100005;
const int MAXL = 22;
int n ,stp,mv,suffix[MAXN],tmp[MAXN];
int sum[MAXN],cnt[MAXN],Rank[MAXL][MAXN];
char str[MAXN];
struct node{
    int start,len;
}A[4*MAXN],q;
int B[4*MAXN];
int LCP(int u,int v){
	int ret=0,i;
	for(i = stp; i >= 0; i--){
		if(Rank[i][u]==Rank[i][v]){
			ret += 1<<i;
			u += 1<<i;
			v += 1<<i;
		}
	}
	return ret;
}
bool equal(int u,int v){
	if(!stp)return str[u]==str[v];
	if(Rank[stp-1][u]!=Rank[stp-1][v]) return false;
	int a = u + mv < n ? Rank[stp-1][u+mv] : -1;
	int b = v + mv < n ? Rank[stp-1][v+mv] : -1;
	return a == b ;
}
void update(){
	int i;
	for(i = 0;i < n; i ++) sum[ i ] = 0;

	int rnk = 0;
	for(i = 0;i < n;i++){
		suffix[ i ] = tmp[ i ];
		if( i&&!equal(suffix[i],suffix[i-1])){
			Rank[stp][suffix[i]]=++rnk;
			sum[rnk+1]=sum[rnk];
		}
		else Rank[stp][suffix[i]]=rnk;
		sum[rnk+1]++;
	}
}
void Sort(){
	int i;
	for(i = 0; i < n; i ++ ) cnt[ i ] = 0;
	memset(tmp,-1,sizeof tmp);
	for(i = 0 ; i < mv; i ++){
		int idx = Rank[ stp - 1 ][ n-i-1 ];
		int x = sum[ idx ];
		tmp[ x + cnt[ idx ] ] = n-i-1;
		cnt[ idx ]++;
	}
	for(i = 0;i < n; i ++ ){
		int idx = suffix[ i ] - mv;
		if(idx<0)continue;
		idx = Rank[stp-1][idx];
		int x = sum[ idx ];
		tmp[ x + cnt[ idx ] ] = suffix[ i ] - mv;
		cnt[idx]++;
	}
	update();
	return;
}
bool cmp(const int &a,const int &b){
	if(str[a]!=str[b]) return str[a]<str[b];
	return false;
}
inline void push(int idx){
    if(A[idx].len != 2*MAXN){
        if(A[2*idx].len>A[idx].len || A[2*idx].len == A[idx].len && Rank[stp][A[2*idx].start] > Rank[stp][A[idx].start]){
            A[2*idx] = A[idx];
        }
        if(A[2*idx + 1].len>A[idx].len || A[2*idx + 1].len == A[idx].len && Rank[stp][A[2*idx + 1].start] > Rank[stp][A[idx].start]){
            A[2*idx + 1] = A[idx];
        }
        A[idx].len = 2*MAXN;
    }
    if(B[idx]!=-1){
        if(B[2*idx]<B[idx]){
            B[2*idx] = B[idx];
        }
        if(B[2*idx+1]<B[idx]){
            B[2*idx + 1] = B[idx];
        }
        B[idx] = -1;
    }
}
void tree_update1(int idx,int lf,int rt,int x,int y){
    if(x<=lf && y>=rt){
        if(A[idx].len>y - x + 1 || A[idx].len==y - x + 1 && Rank[stp][A[idx].start]>Rank[stp][x]){
            A[idx].start = x;
            A[idx].len = y - x + 1;
        }
        return;
    }
    push(idx);
    int mid = (lf + rt) / 2;
    if(x<=mid)
        tree_update1(2*idx,lf,mid,x,y);
    if(y>mid)
        tree_update1(2*idx+1,mid+1,rt,x,y);
}
void tree_update2(int idx,int lf,int rt,int x,int y,int st){
    if(x>y) return;
    if(x<=lf && y>=rt){
        if(B[idx] == -1 || B[idx]<st){
            B[idx] = st;
        }
        return;
    }
    push(idx);
    int mid = (lf + rt) / 2;
    if(x<=mid)
        tree_update2(2*idx,lf,mid,x,y,st);
    if(y>mid)
        tree_update2(2*idx+1,mid+1,rt,x,y,st);
}
void query(int idx,int lf,int rt,int x){
    if(lf == rt){
        int len = B[idx];
        if(len != -1)
            len = x - len + 1;
        else len = 2*MAXN;
        if(len == A[idx].len){
            if(Rank[stp][B[idx]]<Rank[stp][A[idx].start]){
                q.start = B[idx];
                q.len = len;
            }
            else{
                q = A[idx];
            }
        }
        else if(len < A[idx].len){
            q.start = B[idx];
            q.len = len;
        }
        else q = A[idx];
        return;

    }
    push(idx);
    int mid = (lf + rt) / 2;
    if(x<=mid)
        query(2*idx,lf,mid,x);
    else
        query(2*idx+1,mid+1,rt,x);
}
int main(){
    int t;
    scanf ( "%s", str);
    n = strlen(str);
    int i;
    for(i = 0;i < n;i++) tmp[ i ] = i ;
    for(i = 0;i<4*n;i++){
        A[i].len = 2*MAXN;
        B[i] = -1;
    }

    sort(tmp,tmp+n,cmp);
    stp = 0;
    update();
    ++stp;
    for( mv = 1; mv < n;  mv <<= 1){ // compute the suffix array
        Sort();
        stp++;
    }
    stp--;
    for(i = 0;i<=stp; i++)	Rank[ i ][ n ] = -1;
    int prev = 0,cur,mx;
    for(i = 0; i < n - 1; i ++){
        cur = LCP(suffix[i],suffix[i+1]);
        mx = max(cur,prev);
        if(mx < n - suffix[i]){ // there is a unique substring of length mx+1
                                // starting at index suffix[i]
            mx++;
            tree_update1(1,0,n-1,suffix[i],suffix[i]+mx-1); // update range suffix[i] to suffix[i] + mx - 1
            tree_update2(1,0,n-1,suffix[i] + mx , n - 1,suffix[i]); // and from suffix[i] + mx to n
        }
        prev = cur;
    }
    cur = 0;
    mx = max(cur,prev);
    if(mx < n - suffix[i]){
        mx++;
        tree_update1(1,0,n-1,suffix[i],suffix[i]+mx-1);
        tree_update2(1,0,n-1,suffix[i] + mx , n - 1,suffix[i]);
    }
    for(i = 0;i<n;i++){
        query(1,0,n-1,i);    // query for the smallest unique substring length at containing index i
        printf("%d %d\n",q.start+1,q.len);
    }

	return 0;
}