#include <iostream>
#include <fstream>
#include <vector>
//#include <map>
#include <unordered_map>

std::ifstream fin("algsort.in");
std::ofstream fout("algsort.out");

int n;
std::vector<int> heapu;
//std::map<int, int> hashu;
//std::map<int, int> hashuAparitii;
std::unordered_map<int, int> hashuAparitii;
std::unordered_map<int, int> hashu;
//std::vector<int> moFoPos;

void insertu(int val)
{
    heapu.push_back(val);
    int i = heapu.size() / 2;
    int j = heapu.size() - 1;

    hashu[val] = j;
    hashuAparitii[val]++;

    if(hashuAparitii[val] == 1)
    {
        while(i >= 1 && heapu[i] > val)
        {
            hashu[heapu[i]] = j;
            hashu[heapu[j]] = i;

            int aux2 = hashuAparitii[heapu[i]];
            hashuAparitii[heapu[i]] = hashuAparitii[heapu[j]];
            hashuAparitii[heapu[j]] = aux2;

            int aux = heapu[i];
            heapu[i] = heapu[j];
            heapu[j] = aux;

            j = i;
            i = i / 2;
        }
    }
}

void delu(int valoare)
{
    hashuAparitii[valoare]--;
    if(hashuAparitii[valoare] == 0)
    {
        int position = hashu[valoare];
        int valInit = heapu.back();
        position--;

        heapu[hashu[valoare]] = heapu.back();
        hashu[heapu.back()] = hashu[valoare];
//        hashuAparitii[heapu.back()] = hashuAparitii[moFoPos[position]];

        heapu.pop_back();

        int i = hashu[valoare];
        while(i * 2 < heapu.size())
        {
            int val = heapu[i*2];
            int p = 0;

            if(i*2 + 1 < heapu.size() && heapu[i*2+1] < heapu[i*2])
            {
                val = heapu[i*2+1];
                p = 1;
            }

            if(valInit > heapu[i*2+p])
            {
                int a1 = hashu[heapu[i]], a2 = hashu[heapu[i*2+p]];

                int aux2 = hashuAparitii[heapu[i]];
                hashuAparitii[heapu[i]] = hashuAparitii[heapu[i*2+p]];
                hashuAparitii[heapu[i*2+p]] = aux2;

                hashu[heapu[i]] = a2;
                hashu[heapu[i*2 + p]] = a1;

                int aux = heapu[i];
                heapu[i] = heapu[i*2 + p];
                heapu[i*2 + p] = aux;
            }
            else
            {
                break;
            }
            i = i * 2 + p;
        }
    }
}

void citirea()
{
    int x, y;
    fin>>n;
    for(int i = 0; i < n; i++)
    {
        fin>>x;
        if(hashuAparitii[x] == 0)
        {
//            moFoPos.push_back(x);
            insertu(x);
        }
        else
        {
            hashuAparitii[x]++;
        }
    }

//    for(int i = 1; i < heapu.size(); i++)
//    {
//        std::cout<<heapu[i]<<' '<<hashuAparitii[heapu[i]]<<'\n';
//    }
//    std::cout<<'\n';

    for(int i = 1; i <= n; i++)
    {
        fout<<heapu[1]<<' ';
        delu(heapu[1]);
    }
    fout<<'\n';
}

int main()
{
    heapu.push_back(-1);
    citirea();
    return 0;
}