#include <bits/stdc++.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>

#define BITS 8
#define MASK ((1 << BITS) - 1)
#define THRESHOLD 64

using namespace std;

class parser {
public:
    
    explicit parser () {
        /// default c-tor
    }
    
    explicit parser (const char *file_name) {
        fd = open(file_name, O_RDONLY, 0),
        block_number &= 0,
        index &= 0,
        buffer = (char*) mmap(NULL, SIZE, PROT_READ, MAP_SHARED, fd, 0);
    }
    [[gnu::hot]] inline parser &operator >> (int &n) {
        for (;buffer[index] < '0' or buffer[index] > '9'; inc());
        n &= 0;
#ifdef SIGNED
        sign &= 0;
        sign |= (buffer[index - 1] == '-');
#endif
        for (;'0' <= buffer[index] and buffer[index] <= '9'; inc())
            n= 10 * n + buffer[index] - '0';
#ifdef SIGNED
        n ^= ((n ^ -n) & -sign);
#endif
        return *this;
    }
    ~parser () {
        munmap(buffer, SIZE);
        close(fd);
    }
private:
    static const int SIZE = 0x400000; /// 4MB
    int fd, block_number, index;
    char *buffer;
#ifdef SIGNED
    int sign;
#endif
    [[gnu::hot]] inline void inc() {
        if(++index == SIZE)
            index &= 0,
            ++block_number,
            buffer = (char*) mmap(NULL, SIZE, PROT_READ, MAP_SHARED, fd, block_number * SIZE);
    }
};

class writer{
    public:
        writer() {};
        writer(const char *file_name){
            output_file.open(file_name,ios::out | ios::binary);
            output_file.sync_with_stdio(false);
            index=0;}
        inline writer &operator <<(int target){
            aux=0;
            n=target;
            if (!n)
                nr[aux++]='0';
            for (;n;n/=10)
                nr[aux++]=n%10+'0';
            for(;aux;inc())
                buffer[index]=nr[--aux];
            return *this;}
        inline writer &operator <<(const char *target){
            aux=0;
            while (target[aux])
                buffer[index]=target[aux++],inc();
            return *this;}
        ~writer(){
            output_file.write(buffer,index);output_file.close();}
    private:
        fstream output_file;
        static const int SIZE=0x200000;
        int index=0,aux,n;
        char buffer[SIZE],nr[24];
        inline void inc(){
            if(++index==SIZE)
                index=0,output_file.write(buffer,SIZE);}
};
 
parser f ("algsort.in");
writer t ("algsort.out");

int n,v[500010];

inline void insertionSort(int low,int up) {
    for (int i=low;i<up;++i){
        int x=v[i];
        int j=i;
        while ((j>low) and (v[j-1]>x)){
            v[j]=v[j-1];
            --j;
        }
        v[j]=x;
    }
}
 
void radixSort(int low, int up, int bits) {
    int ptr[1<<BITS],bucket[1<<BITS]={ };
    for (int i=low;i<up;++i)
        ++bucket[(v[i]>>bits)&MASK];
    ptr[0]=low;
    bucket[0]+=low;
    for (int i=1;i<(1<<BITS);++i){
        ptr[i]=bucket[i-1];
        bucket[i]+=bucket[i-1];
    }
    for (int i=0;i<(1<<BITS);++i){
        while (ptr[i]!=bucket[i]){
            int elem=v[ptr[i]];
            int bucket=(elem>>bits)&MASK;
            while (bucket!=i){
                int tmp=v[ptr[bucket]];
                v[ptr[bucket]++]=elem;
                elem=tmp;
                bucket=(elem>>bits)&MASK;
            }
        v[ptr[i]++]=elem;
        }
    }
    if (bits){
        for (int i=0;i<(1<<BITS);++i){
        int size=bucket[i]-(i?bucket[i-1]:low);
        if (size>THRESHOLD)
            radixSort(bucket[i]-size,bucket[i],bits-BITS);
        else if (size>1)
            insertionSort(bucket[i]-size,bucket[i]);
        }
    }
}
 
int main()
{
    f>>n;
    for (int i=0;i<n;++i)
        f>>v[i];
    radixSort(0,n,24);
    for (int i=0;i<n;++i)
        t<<v[i]<<" ";
    return 0;
}