// 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 half_block_size, mid, right;

    for (half_block_size = 1; half_block_size <= n; half_block_size *= 2) {
        for (int left = 0; left < n; left += 2*half_block_size) {
            mid = left + half_block_size - 1;
            right = mid + half_block_size;

            if (mid >= n - 1) {
                // acest block este deja sortat;
                // are doar o parte din prima jumatate a blocului -> deja sortat
                break;
            }

            if (right >= n) {
                right = n - 1;  // a 2-a jumatate a block-ului este mai scurta
            }

            merge_reconstruct(left, mid, right);
        }
    }
}

void read_input() {
    ifstream fin(FIN);

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

    fin.close();
}

void print_solution() {
    ofstream fout(FOUT);

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

    fout << "\n";

    fout.close();
}

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

    return 0;
}