////mergesort
//#include <iostream>
//#include <fstream>
//using namespace std;
//ifstream f("algsort.in");
//ofstream g("algsort.out");
//
//int N, v[100];
//
//void merge(int v[], int left, int mij, int right)
//{
//    auto const subArrayOne = mij - left + 1;
//    auto const subArrayTwo = right - mij;
//
//    auto *leftArray = new int[subArrayOne],
//            *rightArray = new int[subArrayTwo];
//
//    // Copy data to temp arrays leftArray[] and rightArray[]
//    for (auto i = 0; i < subArrayOne; i++)
//        leftArray[i] = v[left + i];
//    for (auto j = 0; j < subArrayTwo; j++)
//        rightArray[j] = v[mij + 1 + j];
//
//    auto indexOfSubArrayOne = 0,
//    indexOfSubArrayTwo = 0;
//    int indexOfMergedArray = left;
//
//    while (indexOfSubArrayOne < subArrayOne && indexOfSubArrayTwo < subArrayTwo) {
//        if (leftArray[indexOfSubArrayOne] <= rightArray[indexOfSubArrayTwo]) {
//            v[indexOfMergedArray] = leftArray[indexOfSubArrayOne];
//            indexOfSubArrayOne++;
//        }
//        else {
//            v[indexOfMergedArray] = rightArray[indexOfSubArrayTwo];
//            indexOfSubArrayTwo++;
//        }
//        indexOfMergedArray++;
//    }
//
//    while (indexOfSubArrayOne < subArrayOne) {
//        v[indexOfMergedArray] = leftArray[indexOfSubArrayOne];
//        indexOfSubArrayOne++;
//        indexOfMergedArray++;
//    }
//    // Copy the remaining elements of
//    // right[], if there are any
//    while (indexOfSubArrayTwo < subArrayTwo) {
//        v[indexOfMergedArray] = rightArray[indexOfSubArrayTwo];
//        indexOfSubArrayTwo++;
//        indexOfMergedArray++;
//    }
//}
//
//
//void mergeSort(int v[], int start, int stop)
//{
//    if (start >= stop)
//        return;
//
//    auto mij = start + (stop -start) / 2;
//    mergeSort(v, start, mij);
//    mergeSort(v, mij + 1, stop);
//    merge(v, start, mij, stop);
//}
//
//
//int main() {
//    f >> N;
//    for (int i = 0; i < N; i++)
//        f >> v[i];
//
//    mergeSort(v, 0, N - 1);
//
//    for(int i = 0; i < N; i++)
//        g << v[i] << " ";
//
//    return 0;
//}

//MERGE SORT
//#include <iostream>
//#include <fstream>
//using namespace std;
//ifstream f("algsort.in");
//ofstream g("algsort.out");
//
//int N, v[500001];
//void merge(int v[], int left, int right, int mid)
//{
//    int i, j, k, c[500001];
//    i = left;
//    k = left;
//    j = mid + 1;
//    while (i <= mid && j <= right) {
//        if (v[i] < v[j]) {
//            c[k] = v[i];
//            k++;
//            i++;
//        }
//        else  {
//            c[k] = v[j];
//            k++;
//            j++;
//        }
//    }
//    while (i <= mid) {
//        c[k] = v[i];
//        k++;
//        i++;
//    }
//    while (j <= right) {
//        c[k] = v[j];
//        k++;
//        j++;
//    }
//    for (i = left; i < k; i++)  {
//        v[i] = c[i];
//    }
//}
//
//void merge_sort(int v[], int left, int right)
//{
//    if (left < right){
//        int mid=(left+right)/2;
//        merge_sort(v,left,mid);
//        merge_sort(v,mid+1,right);
//        merge(v,left,right,mid);
//    }
//}
//
//int main()
//{
//    f >> N;
//    for (int i = 0; i < N; i++)
//        f >> v[i];
//    merge_sort(v, 0, N-1);
//    for (int i = 0; i < N; i++)
//        g << v[i] << " ";
//}


//QUICK SORT

#include <iostream>
#include <fstream>

using namespace std;
ifstream f("algsort.in");
ofstream g("algsort.out");

int N, v[500001];

void swap(int *a, int *b) {
    int t = *a;
    *a = *b;
    *b = t;
}

// function to rearrange array
int partition(int v[], int left, int right) {

    int pivot = v[right];
    int i = (left - 1);

    for (int j = left; j < right; j++) {
        if (v[j] < pivot) {

            i++;

            swap(&v[i], &v[j]);
        }
    }

    swap(&v[i + 1], &v[right]);

    return (i + 1);
}

void quickSort(int v[], int left, int right) {
    if (left < right) {
        int pv = partition(v, left, right);
        quickSort(v, left, pv - 1);
        quickSort(v, pv + 1, right);
    }
}

int main() {
    f >> N;
    for (int i = 0; i < N; i++)
        f >> v[i];

    quickSort(v, 0, N - 1);

    for(int i = 0; i < N; i++)
        g << v[i] << " ";
}