#include <iostream>
#include <fstream>

using namespace std;

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

void interclasare(uint64_t *v, uint64_t s_start, uint64_t s_stop, uint64_t d_start, uint64_t d_stop)
{

// dimensiunile initiale ale celor 2 subvectori
uint64_t s_lungime = s_stop - s_start;
uint64_t d_lungime = d_stop - d_start;

// elementele initiale date spre comparare
uint64_t s_jumatate[s_lungime];
uint64_t d_jumatate[d_lungime];

uint64_t i;
uint64_t s = 0;
uint64_t d = 0;

// copierea valorilor in subvectorii temporali
for (i = s_start; i < s_stop; i++, s++)
	{
	 s_jumatate[s] = v[i];
	}

for (i = d_start; i < d_stop; i++, d++)
	{
	 d_jumatate[d] = v[i];
	}

// asezarea valorilor pe pozitiile corespunzatoare
for (i = s_start, s = 0, d = 0; s < s_lungime && d < d_lungime; i++)
{
if (s_jumatate[s] < d_jumatate[d])
		{
		v[i] = s_jumatate[s];
		s++;
		}
	else
		{
		v[i] = d_jumatate[d];
		d++;
		}

}

// completarea cu restul valorilor ramase
for ( ; s < s_lungime; i++, s++)
	v[i] = s_jumatate[s];

for( ; d < d_lungime; i++, d++)
	v[i] = d_jumatate[d];

}


void mergesort(uint64_t stanga, uint64_t dreapta, uint64_t *v)
{
	// cazul de baza pentru iesire din recursivitate
	if (dreapta - stanga <= 1)
		{ return; }

	// determinare intervale
	uint64_t s_start = stanga;
	uint64_t s_stop = (stanga+dreapta)/2;
	uint64_t d_start = s_stop;
	uint64_t d_stop = dreapta;

	// apel recursiv pe partea stanga
	mergesort(s_start, s_stop, v);

	// apel recursiv pe partea dreapta
	mergesort(d_start, d_stop, v);

	// interclasam cele 2 jumatati
	interclasare(v, s_start, s_stop, d_start, d_stop);
}

int main()
{
    uint64_t i, n;

    f>>n;

    uint64_t v[n+1];

    for(i=0; i<n; i++)
        f>>v[i];

    mergesort(0, n, v);

    for(i=0; i<n; i++)
        g<<v[i]<<" ";

    return 0;

}