#include <bits/stdc++.h>
#define n_max 500001

using namespace std;
ifstream f("algsort.in");
ofstream g("algsort.out");
int n;
int v[n_max];

void read()
{
  f>>n;
  for(int i = 1;i <= n;++i)
    f>>v[i];
}

int pivot(int left, int right)
{
  int index = left - 1;
  int p = v[right];

  for(int i = left;i < right;++i)
    if(v[i] >= p)
    {
      index++;
      swap(v[index], v[i]);
    }
  swap(v[index + 1], v[right]);

  return index + 1;
}

void quicksort(int left, int right)
{
  if(left < right)
  {
    int p = pivot(left, right);
    quicksort(left, p - 1);
    quicksort(p + 1, right);
  }
}

#define get_byte(x) ((x >> (8 * byte)) & 255)

void countsort(int *arr1, int *arr2, int byte)
{
  int counter[1 << 8];
  int index[1 << 8];

  memset(counter, 0, sizeof(counter));

  for(int i = 1;i <= n;++i)
    counter[get_byte(arr1[i])]++;
   
  index[0] = 1;
  for(int i = 1;i < (1 << 8);++i)
    index[i] = index[i - 1] + counter[i - 1];
  
  for(int i = 1;i <= n;++i)
    arr2[index[get_byte(arr1[i])]++] = arr1[i];
}

void radixsort()
{
  int tmp[n_max];
  for(int i = 0;i < 4;++i)
    if(i & 1)
      countsort(tmp, v, i);
    else
      countsort(v, tmp, i);
  
}

void merge(int left, int mid, int right)
{
  int len_1 = mid - left + 1;
  int len_2 = right - mid;

  int *l1 = new int[len_1];
  int *l2 = new int[len_2];

  for(int i = 0;i < len_1;++i)
    l1[i] = v[i + left];
  for(int i = 0;i < len_2;++i)
    l2[i] = v[mid + 1 + i];
  
  int index1 = 0, index2 = 0, index_all = left;
  
  while(index1 < len_1 && index2 < len_2)
  {
    if(l1[index1] < l2[index2])
      v[index_all] = l1[index1], index1++;
    else
      v[index_all] = l2[index2], index2++;
    ++index_all;
  }
  
  while(index1 < len_1)
    v[index_all] = l1[index1], ++index1, ++index_all;
  while(index2 < len_2)
    v[index_all] = l2[index2], ++index2, ++index_all;
  
  delete l1;
  delete l2;
}

void mergesort(int left, int right)
{
  if(left < right)
  {
    int mid = (left + right) >> 1;

    mergesort(left, mid);
    mergesort(mid + 1, right);
    merge(left, mid, right);
  }
}

void solve()
{
  mergesort(1, n); 
  for(int i = 1;i <= n;++i)
    g<<v[i]<<" ";
}

int main()
{
  read();
  solve();
  return 0;
}