#include <iostream>
#include <string>

struct suffix
{
    int pos;
    int rank[2];
};

bool operator<(const struct suffix& a, const struct suffix& b)
{
    if (a.rank[0] == b.rank[0])
        return (a.rank[1] < b.rank[1]);

    return (a.rank[0] < b.rank[0]);
}

int get_max_count(suffix arr[], int n)
{
    suffix max_suff = arr[0];
    for (int i = 1; i < n; ++i)
        if (max_suff < arr[i])
            max_suff = arr[i];

    int max_val = (max_suff.rank[0] < max_suff.rank[1]) ? max_suff.rank[1] : max_suff.rank[0];

    return max_val + 1;
}

void radix_sort(suffix A[], int n)
{

    suffix B[n];
    int max_val = get_max_count(A, n);
    int C[max_val];

    for (int d, i = 1; i > -1; --i)
    {
        for (int j = 0; j < max_val; ++j)
        {
            C[j] = 0;
        }

        for (int j = 0; j < n; ++j)
        {
            d = A[j].rank[i];
            C[d]++;
        }

        for (int tmp, count = 0, j = 0; j < max_val; ++j)
        {
            tmp = C[j];
            C[j] = count;
            count += tmp;
        }

        for (int j = 0; j < n; ++j)
        {
            d = A[j].rank[i];
            B[C[d]] = A[j];
            C[d]++;
        }

        for (int j = 0; j < n; ++j)
        {
            A[j] = B[j];
        }
    }
}


int* get_suff_array(std::string str, int n)
{
    suffix suffixes[n];

    for (int i = 0; i < n; ++i)
    {
        suffixes[i].pos = i;
        suffixes[i].rank[0] = str[i] - 'a' + 1;

        if (i < n - 1)
            suffixes[i].rank[1] = str[i + 1] - 'a' + 1;
        else
            suffixes[i].rank[1] = 0;
    }

    radix_sort(suffixes, n);

    int pos_to_suff_idx[n];

    for (int k = 4; k < 2 * n; k = k * 2)
    {
        int rank = 1;
        int prev_rank = suffixes[0].rank[0];
        suffixes[0].rank[0] = rank;
        pos_to_suff_idx[suffixes[0].pos] = 0;

        for (int i = 1; i < n; ++i)
        {
            if (suffixes[i].rank[0] == prev_rank && suffixes[i].rank[1] == suffixes[i - 1].rank[1])
            {
                suffixes[i].rank[0] = rank;
            }
            else
            {
                prev_rank = suffixes[i].rank[0];
                suffixes[i].rank[0] = ++rank;
            }
            pos_to_suff_idx[suffixes[i].pos] = i;
        }

        for (int next_idx, suff_idx, i = 0; i < n; ++i)
        {
            next_idx = suffixes[i].pos + k / 2;
            if (next_idx < n)
            {
                suff_idx = pos_to_suff_idx[next_idx];
                suffixes[i].rank[1] = suffixes[suff_idx].rank[0];
            }
            else
            {
                suffixes[i].rank[1] = 0;
            }
        }

        radix_sort(suffixes, n);
    }

    int* suff_array = new int[n];
    for (int i = 0; i < n; ++i)
        suff_array[i] = suffixes[i].pos;

    return suff_array;
}

void display(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        std::cout << arr[i] << " ";
    std::cout << std::endl;
}

void display_BW(const std::string text, const int SA[])
{
    int n = text.size();
    for (int i = 0; i < n; ++i)
    {
        if (SA[i] != 0)
            std::cout << text[SA[i] - 1];
        else
            std::cout << text[n - 1];
    }
}

int main()
{
    std::string text;
    std::cin >> text;
    int n = text.size();
    int* SA = get_suff_array(text, n);

    // display(SA, n);

    display_BW(text, SA);

    return 0;
}