name

#include <iostream>
#include <vector>

void PocketSort( std::vector<char>& a ) {

    int k = 0; //максимальный элемент в словаре

    std::vector <int> a_num(a.size());
    for (int i = 0; i < a.size(); ++i){
        if (a[i] != '\0') {
            a_num[i] = a[i] - 'a';// делаем числовой суффикс
            std::cout << a_num[i];
        }
    }

    for (int i = 0; i < a_num.size(); ++i){
        if (k < a_num[i])
            k = a_num[i]; //максимальная цифра
    }

    /*std::vector<int> c( k, 0 );
    for( int i = 0; i < a.size(); ++i )
        ++c[a[i]];
    for( int i = 1; i < k; ++i ) {
        c[i] += c[i - 1]; // Концы групп.
    }
    std::vector<int> b( a.size() );
    for( int i = a.size() - 1; i >= 0; --i ) {
        b[--c[a[i]]] = a[i];
    }*/
    //a = std::move( b );
}

/*void BuildSuffArrayStep(std::vector<int>& a, std::vector<int>& pockets)
{
    PocketSort(a);
    std::vector <int> b(a.size(), 0);
    //std::vector <int> c(pockets.size(), 0);

    for (int i = 0; i < pockets.size(); ++i)
        pockets[i] = c[i];

    for ( int k = 0; 2^k < a.size(); ++k )
    {
        for( int i = a.size() - 1; i >= 0; --i )
            b[--c[pockets[a[i] – 2^k]] = a[i] – 2^k;
    }


    a = std::move( b );
}*/

int main() {

    char ival;
    std::vector <char> v;
    while (std::cin >> ival)
        v.push_back(ival);
    v.push_back('\0'); //считали строку с поправкой на длину

    PocketSort(v);
    return 0;
}
/*
int main() {

    char *s; // входная строка
    int n; // длина строки

    std::cin >> n;
    for (int i = 0; i < n; ++i)
        std::cin >> s[i];

    const int maxlen = n; // максимальная длина строки (не меняется жи?!)
    const int alphabet = 26; // размер алфавита, <= maxlen

    int p[maxlen], cnt[maxlen], c[maxlen];
    //memset (cnt, 0, alphabet * sizeof(int));
    for (int i = 0; i < n; ++i)
        ++cnt[s[i]]; //запись вхождений
    for (int i = 1; i < alphabet; ++i)
        cnt[i] += cnt[i-1]; //границы групп
    for (int i=0; i<n; ++i)
        p[--cnt[s[i]]] = i; //отсортированная строка
    c[p[0]] = 0;
    int classes = 1;
    for (int i = 1; i < n; ++i) { //классы эквивалентности
        if (s[p[i]] != s[p[i - 1]])
            ++classes;
        c[p[i]] = classes - 1; //классы с 0
    }

    int pn[maxlen], cn[maxlen];

    for (int h = 0; (1 << h) < n; ++h) {
        for (int i = 0; i < n; ++i) {
            pn[i] = p[i] - (1 << h);
            if (pn[i] < 0) pn[i] += n;
        } //переход от первой степ 2ки ко 2ой степ 2ки

        //memset(cnt, 0, classes * sizeof(int));
        for (int i = 0; i < n; ++i)
            ++cnt[c[pn[i]]];
        for (int i = 1; i < classes; ++i)
            cnt[i] += cnt[i - 1];
        for (int i = n - 1; i >= 0; --i)
            p[--cnt[c[pn[i]]]] = pn[i];
        cn[p[0]] = 0;
        classes = 1;
        for (int i = 1; i < n; ++i) {
            int mid1 = (p[i] + (1 << h)) % n, mid2 = (p[i - 1] + (1 << h)) % n;
            if (c[p[i]] != c[p[i - 1]] || c[mid1] != c[mid2])
                ++classes;
            cn[p[i]] = classes - 1;
        }
        //memcpy(c, cn, n * sizeof(int));
        std::cout << cn[0];
    }
}
 */