#include <fstream>
#include <string>

using namespace std;

char NUL = 'a' - 1;
int SIZE = 'z' - 'a' + 2;


struct Item
{
    int left;
    int right;
    Item *parent;
    Item **children;
    Item *suffix;

    int num;

    Item(int l = -1, int r = -1, Item *p = NULL)
    {
        left = l;
        right = r;
        parent = p;
        children = new Item* [SIZE];
        for (int i = 0; i < SIZE; i++)
        {
            children[i] = NULL;
        }
    }
};

struct Position
{
    Item *vertex;
    int shift;

    Position(Item *v, int s)
    {
        vertex = v;
        shift = s;
    }
};

Item *last;
Item *root = new Item(-1, -1, NULL);

std::string s;


void add(Position position, int l, int r)
{
    if (position.shift == 0)
    {
        position.vertex->children[s[l] - NUL] = new Item(l, r, position.vertex);
        last = position.vertex->children[s[l] - NUL];
    }
    else
    {
        Item *temp = new Item(position.vertex->left, position.vertex->right - position.shift, position.vertex->parent);
        position.vertex->left = position.vertex->right - position.shift + 1;
        position.vertex->parent = temp;
        temp->parent->children[s[temp->left] - NUL] = temp;
        temp->children[s[position.vertex->left] - NUL] = position.vertex;

        temp->children[s[l] - NUL] = new Item(l, r, temp);

        last = temp->children[s[l] - NUL];
    }
}

void jump(Position pos, int pretailL, int pretailR)
{
    while (pretailR - pretailL >= 0)
    {
        pos.vertex = pos.vertex->children[s[pretailL] - NUL];
        pos.shift = pos.vertex->right - pos.vertex->left + 1;
        if (pretailL + pos.shift <= pretailR + 1)
        {
            pretailL += pos.shift;
            pos.shift = 0;

        }
        else
        {
            pos.shift -= pretailR - pretailL + 1;
            pretailL = pretailR + 1;
        }
    }
}

int go(Position pos, int tailL, int tailR)
{
    while (tailR - tailL >= 0)
    {
        if (pos.shift == 0)
        {
            if (pos.vertex->children[s[tailL] - NUL] == NULL)
            {
                return tailL;
            }
            else
            {
                pos.vertex = pos.vertex->children[s[tailL] - NUL];
                pos.shift = pos.vertex->right - pos.vertex->left + 1;
            }
        }

        if (s[tailL] == s[pos.vertex->right - pos.shift + 1])
        {
            tailL++;
            pos.shift--;
        }
        else
        {
            return tailL;
        }
    }
    return tailL;
}

long long countSubstrings(Item *vertex)
{
    long long res = 0;
    for (int i = 1; i < SIZE; i++)
    {
        if (vertex->children[i] != NULL)
        {
            res += countSubstrings(vertex->children[i]);
            res += vertex->children[i]->right - vertex->children[i]->left + 1;
            if (s[vertex->children[i]->right] == NUL)
            {
                res--;
            }
        }
    }
    return res;
}

void addSuf(int i)
{
    if (last == NULL)
    {
        add(new Position(root, 0), i, s.length() - 1);
    }
    else
    {
        Item *father = last->parent;
        int tailL = last->left;
        int tailR = last->right;

        if (father == root)
        {
            tailL++;
            Position pos = new Position(father, 0);
            tailL = go(pos, tailL, tailR);
            add(pos, tailL, tailR);
        }
        else
        {
            Item *ver = father->parent;
            int pretailL = father->left;
            int pretailR = father->right;
            Position pos = new Position(ver->suffix, 0);
            if (ver == root)
            {
                pretailL++;
            }
            jump(pos, pretailL, pretailR);

            if (pos.shift == 0)
            {
                father->suffix = pos.vertex;
            }

            tailL = go(pos, tailL, tailR);
            add(pos, tailL, tailR);

            if (father->suffix == NULL)
            {
                father->suffix = last->parent;
            }
        }
    }
}

int main()
{
    std::ifstream input("count.in");
    std::ofstream output("count.out");

    input >> s;
    root->suffix = root;

    for (int i = 0; i < s.length(); i++)
    {
        addSuf(i);
    }

    output << countSubstrings(root);
}