// Testare: infoarena -> arhiva educationala -> sortare prin comparare

#include <bits/stdc++.h>
#define FIN "algsort.in"
#define FOUT "algsort.out"

using namespace std;

int n;
vector<int> v(500003);

void merge_reconstruct(int left, int mid, int right) {                               
    int i, j;                                                                   
    vector<int> aux;                                                            
                                                                                
    i = left;                                                                   
    j = mid + 1;                                                                
    while(i <= mid && j <= right) {                                             
        if (v[i] < v[j]) {                                                      
            aux.push_back(v[i]);                                                
            i++;                                                                
        } else {                                                                
            aux.push_back(v[j]);                                                
            j++;                                                                
        }                                                                       
    }                                                                           
                                                                                
    while (i <= mid) {                                                          
        aux.push_back(v[i]);                                                    
        i++;                                                                    
    }                                                                           
                                                                                
    while (j <= right) {                                                        
        aux.push_back(v[j]);                                                    
        j++;                                                                    
    }                                                                           
                                                                                
    for (int k = left; k <= right; k++) {                                       
        v[k] = aux[k - left];                                                   
    }                                                                           
}          

// varianta iterativa
void merge_sort() {                                                        
    int block_size, mid, right;                                                 
                                                                                
    for (block_size = 2; block_size <= n; block_size *= 2) {                    
        for (int left = 0; left < n; left += block_size) {                      
            right = left + block_size - 1;                                      
            if (right >= n) {                                                   
                break;                                                          
            }                                                                   
                                                                                
            mid = (right + left) / 2;                                           
                                                                                
            merge_reconstruct(left, mid, right);                                     
        }                                                                       
    }                                                                           
                                                                                
    block_size /= 2;                                                            
                                                                                
    if (block_size < n) {                                                       
        int left = 0;                                                           
        right  = n-1;                                                           
        mid = block_size-1;                                                     
                                                                                
        merge_reconstruct(left, mid, right);                                         
    }                                                                           
}

void read_input() {
    ifstream fin(FIN);

    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> v[i];
    }

    fclose(fin);
}

void print_solution() {
    ofstream fout(FOUT);

    for (int i = 0; i < n; i ++) {
        cout << v[i] << " ";
    }

    cout << "\n";

    fclose(fout);
}

int main() {
    read_input();
    merge_sort();
    print_solution();

    return 0;
}