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

const int MAX_NODES = 2000010;

// Suffix Automaton Components
int n;                          // Length of the input string
int dp[MAX_NODES];              // Dynamic programming array
char inputStr[MAX_NODES];       // Input string
int suffixLink[MAX_NODES];      // Suffix links for SAM
int length[MAX_NODES];          // Length of each state in SAM
int transitions[MAX_NODES][26]; // Transitions for each state
int lastState = 1;              // The last state in SAM
int totalStates = 1;             // Total number of states in SAM

// Function to insert a character into the Suffix Automaton
void insertChar(int charIndex) {
    int newState = ++totalStates;
    length[newState] = length[lastState] + 1;
    int current = lastState;
    
    // Update transitions for the current state
    while (current && !transitions[current][charIndex]) {
        transitions[current][charIndex] = newState;
        current = suffixLink[current];
    }
    
    if (!current) {
        suffixLink[newState] = 1;
    } else {
        int existingState = transitions[current][charIndex];
        if (length[current] + 1 == length[existingState]) {
            suffixLink[newState] = existingState;
        } else {
            int cloneState = ++totalStates;
            length[cloneState] = length[current] + 1;
            memcpy(transitions[cloneState], transitions[existingState], sizeof(transitions[cloneState]));
            suffixLink[cloneState] = suffixLink[existingState];
            suffixLink[existingState] = cloneState;
            suffixLink[newState] = cloneState;
            
            while (current && transitions[current][charIndex] == existingState) {
                transitions[current][charIndex] = cloneState;
                current = suffixLink[current];
            }
        }
    }
    
    lastState = newState;
}

// Tree structure for DFS
vector<int> children[MAX_NODES];
int inTime[MAX_NODES], outTime[MAX_NODES], currentTime;
int ancestor[MAX_NODES][20];

// Binary Indexed Tree (Fenwick Tree) for range queries
int BIT[MAX_NODES];

// Function to perform DFS and prepare for ancestor queries
void dfs(int node) {
    inTime[node] = ++currentTime;
    ancestor[node][0] = suffixLink[node];
    
    for (int i = 1; i < 20; ++i) {
        ancestor[node][i] = ancestor[ancestor[node][i - 1]][i - 1];
    }
    
    for (int child : children[node]) {
        dfs(child);
    }
    
    outTime[node] = currentTime;
}

// Function to update the Binary Indexed Tree
void updateBIT(int index, int value) {
    while (index <= currentTime) {
        BIT[index] += value;
        index += index & (-index);
    }
}

// Function to query the Binary Indexed Tree
int queryBIT(int index) {
    int result = 0;
    while (index > 0) {
        result += BIT[index];
        index -= index & (-index);
    }
    return result;
}

// Function to calculate the number of relevant substrings
int calculate(int left, int right, int ed[]) {
    int state = ed[right];
    for (int i = 19; i >= 0; --i) {
        if (ancestor[state][i] && length[ancestor[state][i]] >= right - left + 1) {
            state = ancestor[state][i];
        }
    }
    return queryBIT(outTime[state]) - queryBIT(inTime[state] - 1);
}

int stackIndices[MAX_NODES], stackTop;

// Main processing function
void process() {
    // Read input string
    scanf("%s", inputStr + 1);
    n = strlen(inputStr + 1);
    
    // Reverse the string
    reverse(inputStr + 1, inputStr + n + 1);
    
    // Build the Suffix Automaton
    int ed[MAX_NODES];
    for (int i = 1; i <= n; ++i) {
        insertChar(inputStr[i] - 'a');
        ed[i] = lastState;
    }
    
    // Build the tree based on suffix links
    for (int i = 2; i <= totalStates; ++i) {
        children[suffixLink[i]].push_back(i);
    }
    
    // Perform DFS to set inTime and outTime
    dfs(1);
    
    // Dynamic Programming to compute the result
    for (int i = 1; i <= n; ++i) {
        updateBIT(inTime[ed[i]], 1);
        dp[i] = 1;
        
        while (stackTop > 0) {
            int previousIndex = stackIndices[stackTop];
            dp[i] = max(dp[i], calculate(stackIndices[stackTop] + 1, i, ed) - dp[previousIndex]);
            
            if (dp[previousIndex] < dp[i]) {
                break;
            }
            stackTop--;
        }
        
        stackIndices[++stackTop] = i;
    }
    
    // Output the result
    printf("%d\n", dp[n]);
}

int main(){
    // Number of test cases
    int T = 1;
    while(T--){
        process();
    }
    return 0;
}