#include <bits/stdc++.h>

using namespace std;

const int MAX_N = 300000 + 5;

int N, t;
struct SAM_Node{
    SAM_Node *fa, *next[26];
    int len;
    void clear() {
        fa = 0;
        memset(next, 0, sizeof(next));
    }
}pool[MAX_N * 2];
SAM_Node *rt, *tl, *ed[MAX_N];
int deg[MAX_N << 1], a[MAX_N << 1];
long long ans;

SAM_Node* newnode(int len) {
    SAM_Node* cur = tl ++;
    cur -> clear();
    cur -> len = len;
    return cur;
}

void SAM_init() {
    tl = pool;
    rt = newnode(0);
}

SAM_Node* extend(SAM_Node *lst, int x) {
    SAM_Node *p = lst, *np = newnode(p -> len + 1);
    while (p && !p -> next[x]) {
        p -> next[x] = np;
        p = p -> fa;
    }
    if (!p) np -> fa = rt;
    else {
        SAM_Node* q = p -> next[x];
        if (q -> len == p -> len + 1) np -> fa = q;
        else {
            SAM_Node *nq = newnode(p -> len + 1);
            memcpy(nq -> next, q -> next, sizeof(q -> next));
            nq -> fa = q -> fa;
            q -> fa = np -> fa = nq;
            while (p && p -> next[x] == q) {
                p -> next[x] = nq;
                p = p -> fa;
            }
        }
    }
    return np;
}

char s[MAX_N];
int minlen[MAX_N << 1];
long long f[MAX_N << 1];

long long solve(int x) {
    if (!rt -> next[x]) return 0;
    long long res = 0;
    memset(f, 0, sizeof(f));
    memset(minlen, 0x3f, sizeof(minlen));
    int u = rt -> next[x] - pool;
    f[u] = 1;
    minlen[u] = 1;
    for (int i = 2; i <= t; i ++) {
        u = a[i];
        if (!f[u]) continue;
        int len2 = pool[u].fa -> len + 1;
        if (pool[u].next[x]) {
            if (minlen[u] == len2)
                res += f[u] - 1;
            else res += f[u];
        }
        if (pool[u].fa -> next[x] && minlen[u] == len2) res ++;
        for (int j = 0; j < 26; j ++) {
            if (!pool[u].next[j]) continue;
            int v = pool[u].next[j] - pool;
            f[v] += f[u];
            minlen[v] = min(minlen[v], minlen[u] + 1);
        }
    }
    return res;
}

int main() {
    scanf("%s", s + 1);
    N = strlen(s + 1);
    SAM_init();
    ed[0] = rt;
    for (int i = 1; i <= N; i ++) {
        ed[i] = extend(ed[i - 1], (int)s[i] - 97);
    }
    for (SAM_Node *u = pool; u != tl; u ++) {
        for (int i = 0; i < 26; i ++) {
            if (u -> next[i]) {
                int v = u -> next[i] - pool;
                deg[v] ++;
            }
        }
    }
    queue <int> q;
    for (int i = 0; i < tl - pool; i ++)
        if (!deg[i]) q.push(i);
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        a[++ t] = u;
        for (int i = 0; i < 26; i ++) {
            if (!pool[u].next[i]) continue;
            int v = pool[u].next[i] - pool;
            if (! -- deg[v]) q.push(v);
        }
    }
    for (int i = 0; i < 26; i ++) ans += solve(i);
    printf("%lld\n", ans);
    
    return 0;
}