#pragma GCC optimize("O3,unroll-loops")
#include<bits/stdc++.h>
using namespace std;

const int N=1e6+1,L=20;

string s;
int n;
int dp[N+1];
int mn[L][N];
int sa[N],lcp[N];
vector<int>opt;
int rev[N];
int ft[N];
int lg[N+1];

namespace yo{
const int Max_N = 1e6+1;
namespace SA_IS
{
    int *sa;
    
    template<typename _Char>
    void sais_core(const int n, const int m, const _Char s[], char type[], int lms[], int cnt[])
    {
        int n1 = 0, ch = -1;
        
        type[n - 1] = 1;
        for (int i = n - 2; i >= 0; --i)
            type[i] = s[i] == s[i + 1] ? type[i + 1] : s[i] < s[i + 1];
        
        std::fill(cnt, cnt + m, 0);
        for (int i = 0; i < n; ++i)
            ++cnt[static_cast<int>(s[i])];
        std::partial_sum(cnt, cnt + m, cnt);
        
        auto induced_sort = [&](const int v[])
        {
            std::fill(sa, sa + n, 0);
            
            int *cur = cnt + m;
            auto push_S = [&](const int x) { sa[--cur[static_cast<int>(s[x])]] = x; };
            auto push_L = [&](const int x) { sa[cur[static_cast<int>(s[x])]++] = x; };
            
            std::copy(cnt, cnt + m, cur);
            for (int i = n1 - 1; i >= 0; --i)
                push_S(v[i]);
            
            std::copy(cnt, cnt + m - 1, cur + 1);
            for (int i = 0; i < n; ++i)
                if (sa[i] > 0 && type[sa[i] - 1] == 0)
                    push_L(sa[i] - 1);
            
            std::copy(cnt, cnt + m, cur);
            for (int i = n - 1; i >= 0; --i)
                if (sa[i] > 0 && type[sa[i] - 1])
                    push_S(sa[i] - 1);
        };
        
        for (int i = 1; i < n; ++i)
            if (type[i - 1] == 0 && type[i] == 1)
                type[i] = 2, lms[n1++] = i;
        induced_sort(lms);
        
        auto lms_equal = [&](int x, int y)
        {
            if (s[x] == s[y])
                while (s[++x] == s[++y] && type[x] == type[y])
                    if (type[x] == 2 || type[y] == 2)
                        return true;
            return false;
        };
        
        int *s1 = std::remove_if(sa, sa + n, [&](const int x) { return type[x] != 2; });
        for (int i = 0; i < n1; ++i)
            s1[sa[i] >> 1] = ch += ch <= 0 || !lms_equal(sa[i], sa[i - 1]);
        for (int i = 0; i < n1; ++i)
            s1[i] = s1[lms[i] >> 1];
        
        if (ch + 1 < n1)
            sais_core(n1, ch + 1, s1, type + n, lms + n1, cnt + m);
        else
            for (int i = 0; i < n1; ++i)
                sa[s1[i]] = i;
        
        for (int i = 0; i < n1; ++i)
            lms[n1 + i] = lms[sa[i]];
        induced_sort(lms + n1);
    }
    
    template<typename _Char>
    void main(const _Char s[], const int n, const int m)
    {
        static int _lms[Max_N], _cnt[Max_N << 1];
        static char _type[Max_N << 1];
        sais_core(n + 1, m, s, _type, _lms, _cnt);
    }
}
void suffix_array(){
    SA_IS::sa = sa;
    SA_IS::main(s.c_str(), n, 128);
    for(int i=0;i<n;i++)sa[i]=sa[i+1];
}
void lcp_array(){
    for(int i=0;i<n;i++)rev[sa[i]]=i;
    int pre=0;
    for(int i=0;i<n;i++){
        if(rev[i]<n-1){
            int j=sa[rev[i]+1];
            while(max(i,j)+pre<n&&s[i+pre]==s[j+pre])++pre;
            lcp[rev[i]]=pre;
            if(pre>0)--pre;
        }
    }
}
}

void ftadd(int i,int x){
    while(i<n)ft[i]+=x,i|=i+1;
}
int ftqry(int i){
    int x=0;
    while(i>=0)x+=ft[i],i&=i+1,i--;
    return x;
}

int qry(int l, int r){
    assert(l<=r);
    int x=lg[r-l+1];
    return min(mn[x][l],mn[x][r-(1<<x)+1]);
}
int f(int l, int r){
    int sz=r-l,pl=rev[l],pr=rev[l];
    int low,hi;
    low=0,hi=pl;
    while(low<hi){
        int mid=(low+hi)/2;
        qry(mid,pl-1)>=sz?hi=mid:low=mid+1;
    }
    pl=low;
    low=pr,hi=n-1;
    while(low<hi){
        int mid=(low+hi)/2+1;
        qry(pr,mid-1)>=sz?low=mid:hi=mid-1;
    }
    pr=low;
    return ftqry(pr)-ftqry(pl-1)-dp[r];
}

int main(){
    cin.tie(0)->sync_with_stdio(0);
    cin>>s;
    n=s.size();
    yo::suffix_array();
    yo::lcp_array();
    lg[1]=0;
    for(int i=2;i<=n;i++)lg[i]=lg[i/2]+1;
    for(int i=0;i<n-1;i++)mn[0][i]=lcp[i];
    for(int l=1;1<<l<n;l++)for(int i=0;i+(1<<l)<=n;i++)mn[l][i]=min(mn[l-1][i],mn[l-1][i+(1<<(l-1))]);
    opt.push_back(n);
    for(int i=n-1;i>=0;i--){
        ftadd(rev[i],1);
        dp[i]=0;
        while(1){
            int j=opt.back();
            dp[i]=max(dp[i],f(i,j));
            if(dp[i]<=dp[j])opt.pop_back();
            else break;
        }
        opt.push_back(i);
    }
    cout<<dp[0]<<'\n';
}