#include <bits/stdc++.h>
using std::bitset;
using std::cout;
using std::deque;
using std::endl;
using std::greater;
using std::lower_bound;
using std::make_pair;
using std::map;
using std::max;
using std::min;
using std::multimap;
using std::multiset;
using std::nth_element;
using std::pair;
using std::priority_queue;
using std::queue;
using std::reverse; 
using std::set;
using std::sort;
using std::sqrt;
using std::stable_sort;
using std::string;
using std::swap;
using std::unique;
using std::upper_bound;
using std::vector;
typedef long long li;
typedef long double lf; 

inline li read(){
	li ans = 0, f = 1;
	char ch = getchar();
	while(ch < '0' || ch > '9'){
		f = (ch == '-') ? -1 : 1;
		ch = getchar();
	}
	while(ch <= '9' && ch >= '0'){
		ans = ans * 10 + (ch ^ 48);
		ch = getchar();
	}
	return ans * f;
} 

struct SA{
    li sa[1000010], rk[2000010], oldsa[1000010], oldrk[2000010], height[1000010], cnt[1000010];
    void work(string s){
        li n = s.length() - 1;
        memset(rk, 0, sizeof rk), memset(oldrk, 0, sizeof oldrk), memset(cnt, 0, sizeof cnt);
        li m = 1e6, lenp = 0;
        for(li i = 1; i <= n; i++) cnt[rk[i] = s[i]]++;
        for(li i = 1; i <= m; i++) cnt[i] += cnt[i - 1];
        for(li i = n; i; i--) sa[cnt[rk[i]]--] = i;
        memcpy(oldrk, rk, (n + 5) * sizeof(li));
        for(li i = 1; i <= n; i++){
            if(oldrk[sa[i]] == oldrk[sa[i - 1]]) rk[sa[i]] = lenp;
            else rk[sa[i]] = ++lenp;
        }
        for(li w = 1; w <= n; w <<= 1, m = lenp){
            memset(cnt, 0, (m + 5) * sizeof(li));
            memcpy(oldsa, sa, (n + 5) * sizeof(li));
            for(li i = 1; i <= n; i++) cnt[rk[oldsa[i] + w]]++;
            for(li i = 1; i <= m; i++) cnt[i] += cnt[i - 1];
            for(li i = n; i; i--) sa[cnt[rk[oldsa[i] + w]]--] = oldsa[i];

            memset(cnt, 0, (m + 5) * sizeof(li));
            memcpy(oldsa, sa, (n + 5) * sizeof(li));
            for(li i = 1; i <= n; i++) cnt[rk[oldsa[i]]]++;
            for(li i = 1; i <= m; i++) cnt[i] += cnt[i - 1];
            for(li i = n; i; i--) sa[cnt[rk[oldsa[i]]]--] = oldsa[i];

            memcpy(oldrk, rk, (n + 5) * sizeof(li));
            lenp = 0;
            for(li i = 1; i <= n; i++){
                if(oldrk[sa[i]] == oldrk[sa[i - 1]] && oldrk[sa[i] + w] == oldrk[sa[i - 1] + w]) rk[sa[i]] = lenp;
                else rk[sa[i]] = ++lenp;
            }
            if(n == lenp) break;
        }   
    }
} sa;

struct node{
    li l, r, p;
    bool operator < (const node b) const{
        return l == b.l ? r < b.r : l < b.l;
    }
    bool operator == (const node b) const{
        return l == b.l && r == b.r;
    }
};

li poww[1000010];
const li base = 251;

struct Hash{
    string s;
    li hash[1000010], n;

    void work(string ss){
        s = ss;
        n = s.length() - 1;
        for(li i = 1; i < s.length(); i++) hash[i] = hash[i - 1] + (s[i] - 'a' + 1) * poww[i];
    }

    li lcp(li x, li y){
        li l = 1, r = min(n - y + 1, n - x + 1), ans = 0;
        while(l <= r){
            li mid = (l + r) >> 1;
            li h1 = (hash[x + mid - 1] - hash[x - 1]) * poww[n - (x + mid - 1)];
            li h2 = (hash[y + mid - 1] - hash[y - 1]) * poww[n - (y + mid - 1)];
            if(h1 == h2){
                ans = mid;
                l = mid + 1;
            } else r = mid - 1;
        }
        return ans;
    }
};

struct runs{
    li lenrun, lenstack, stack[1000010];
    node run[2000010];
    Hash h1, h2;
    void get(string s){
        string ss = s;
        reverse(ss.begin() + 1, ss.end());
        h1.work(s), h2.work(ss);
        lenstack = 0;
        li n = s.length() - 1;
        stack[lenstack = 0] = n + 1;
        for(li i = n; i; i--){
            while(lenstack){
                li x = min(stack[lenstack - 1] - stack[lenstack], stack[lenstack] - i);
                li lcp = h1.lcp(i, stack[lenstack]);
                lcp = min(x, lcp);
                if((x == lcp && stack[lenstack - 1] - stack[lenstack] > stack[lenstack] - i) || (x > lcp && s[i + lcp] < s[stack[lenstack] + lcp])) lenstack--;
                else break;
            }
            li j = stack[lenstack];
            stack[++lenstack] = i;
            li x = h2.lcp(n - i + 2, n - j + 2);
            if(x < j - i){
                li y = h1.lcp(i, j);
                if(x + y >= j - i){
                    run[++lenrun] = {i - x, j + y - 1, j - i};
                }
            }
        }
    }

    void work(string s){
        lenrun = 0;
        get(s);
        for(li i = 0; i < s.length(); i++) s[i] = 'z' - (s[i] - 'a');
        get(s);
        sort(run + 1, run + 1 + lenrun);
        lenrun = unique(run + 1, run + 1 + lenrun) - 1 - run;
    }
} run;

int main(){
    freopen("wonderful.ans", "r", stdin);
    freopen("www.ww", "w", stdout); 
    poww[0] = 1;
    for(li i = 1; i <= 1e6; i++) poww[i] = poww[i - 1] * base;
    string s;
    std::cin >> s;
    s = " " + s;
    run.work(s);
    cout << run.lenrun << endl;
    for(li i = 1; i <= run.lenrun; i++){
        printf("%lld %lld %lld\n", run.run[i].l, run.run[i].r, run.run[i].p);
    }
    return 0;
}