//~ while (clock()<=69*CLOCKS_PER_SEC)
//~ #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
//~ #pragma GCC target ("avx2")
//~ #pragma GCC optimize("Ofast")
//~ #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//~ #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

template <typename T>
using ordered_set =
    tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
  enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i; ris; }
eni(==) ris << range(begin(i), end(i)); }
sim, class b dor(pair < b, c > d) {
  ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
  *this << "[";
  for (auto it = d.b; it != d.e; ++it)
    *this << ", " + 2 * (it == d.b) << *it;
  ris << "]";
}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "

#define shandom_ruffle random_shuffle

using ll=long long;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
using vi=vector<int>;
using vll=vector<ll>;
const int nax=2000*1007;

struct suffix_automaton {
	vector<map<char,int>> edges;
	vector<int> link, length;
	int last;
	suffix_automaton(string s) {
		edges.push_back(map<char,int>());
		link.push_back(-1);
		length.push_back(0);
		last = 0;
		for (int i=0; i<(int)s.size(); i++) {
			edges.push_back(map<char,int>());
			length.push_back(i+1);
			link.push_back(0);
			int r = edges.size() - 1;
			int p = last;
			while (p >= 0 && !edges[p].count(s[i])) {
				edges[p][s[i]] = r;
				p = link[p];
			}
			if (p != -1) {
				int q = edges[p][s[i]];
				if (length[p] + 1 == length[q]) {
					link[r] = q;
				}
				else {
					edges.push_back(edges[q]);
					length.push_back(length[p] + 1);
					link.push_back(link[q]);
					int qq = edges.size()-1;
					link[q] = link[r] = qq;
					while (p >= 0 && edges[p][s[i]] == q) {
						edges[p][s[i]] = qq;
						p = link[p];
					}
				}
			}
			last = r;
		}
	}
};

suffix_automaton X=suffix_automaton("");

int n;
char wcz[nax];

int dp[nax];

int m;
vi drz[nax];

int czas;
int pre[nax];
int post[nax];
vi jump[nax];

int fen[nax];

void pisz(int v)
{
	for (int i=v; i<nax; i+=(i&(-i)))
		fen[i]++;
}

int czyt(int a, int b)
{
	int ret=0;
	for (int i=b; i; i-=(i&(-i)))
		ret+=fen[i];
	for (int i=a-1; i; i-=(i&(-i)))
		ret-=fen[i];
	return ret;
}

void dfs1(int v, int oj)
{
	jump[v].push_back(oj);
	while(jump[v].back()>=0)
	{
		int a=jump[v].back();
		int b=min(jump[v].size(), jump[a].size());
		jump[v].push_back(jump[a][b-1]);
	}
	czas++;
	pre[v]=czas;
	for (int i : drz[v])
		dfs1(i, v);
	post[v]=czas;
}

int pyt(int v, int dlu)
{
	for (int i=40; i>=0; i--)
	{
		if (i+1>=(int)jump[v].size())
		{
			i=(int)jump[v].size()-1;
			continue;
		}
		if (X.length[jump[v][i]]>=dlu)
			v=jump[v][i];
	}
	return czyt(pre[v], post[v]);
}

int main()
{
	scanf("%s", wcz+1);
	n=strlen(wcz+1);
	{
		string s="";
		for (int i=n; i; i--)
			s.push_back(wcz[i]);
		X=suffix_automaton(s);
	}
	m=X.link.size();
	for (int i=1; i<m; i++)
		drz[X.link[i]].push_back(i);
	
	dfs1(0, -1);
	
	vi stos;
	int v=0;
	for (int i=n; i; i--)
	{
		v=X.edges[v][wcz[i]];
		pisz(pre[v]);
		dp[i]=-1;
		stos.push_back(i+1);
		while(1)
		{
			dp[i]=max(dp[i], pyt(v, stos.back()-i)-dp[stos.back()]);
			if (dp[i]<=dp[stos.back()])
				stos.pop_back();
			else
				break;
		}
	}
	printf("%d\n", dp[1]);
	return 0;
}