#include<stdio.h>
#include <iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
using namespace std;
 
/*// ----- output ------ //
      // friend ostream& operator<<(stream& out,T& ob);
      template<>
      std::ostream& Vector<Complex>::operator<<(std::ostream &o, Complex& z)
      {
        out << z.real << " + " << z.imaginary;
        return out;
      }
*/
template<typename T>
class Vector
{
    private:

        Vector(const Vector &);
        int dim_alocata,dim_total;
        T * data;

    public:

        Vector() : dim_alocata(0), dim_total(2), data(new T[0]) {};
       // Vector(int dim_tot);
        Vector(const T & init_value);

        T* resize();
        int size();
        void info();

        void push(T elem);
        bool find(T elem);
        void sort();
        void erase(int pos);

        T & operator[](int cols);
        const T& operator[](int cols) const;
        void operator=(const Vector<T>&);
        Vector<T> operator+(const Vector<T>&);

        virtual ~Vector();


};
/*
template<typename T>
Vector<T>::Vector(const Vector<T> &init_vect) : dim_alocata(0)
{
	dim_total = init_vect.dim_total;
	data = new T[dim_total];
	for(int i = 0; i < dim_total; i++)
        data[i] = init_vect.data[i];
    dim_alocata = dim_total;
}
*/

template<class T>
Vector<T>::Vector(const T &init_value) : dim_total(2), dim_alocata(2)
{
	data = new T[dim_total];
	for (int i = 0; i < dim_total; i++)
		data[i] = init_value;
}
/*
template<class T>
Vector<T>::Vector(int dim_tot) : dim_total(dim_tot)
{
    data = new T[dim_total];
}
*/
template<typename T>
T* Vector<T>::resize()
{
	int new_dim = dim_total*2;
	T* new_data = new T[new_dim];

	for(int i = 0; i < dim_alocata; i++)
        new_data[i] = data[i];



  //  dim_alocata = dim_total;
	dim_total = new_dim;

	return new_data;
   // delete[] new_data;
}

template<typename T>
inline T & Vector<T>::operator[](int pos)
{
	if(pos <= dim_total)
        return data[pos];

	//std::cout << std::endl << "out of bounds; ";
//	data = resize();
	//return resize()[pos];
	//
	return data[dim_alocata];
}


template<typename T>
const T & Vector<T>::operator[](int pos) const
{
	if(pos < dim_total)
	return data[pos];

	//std::cout << "out of bounds; ";
	//return data[dim_alocata];
}

template<typename T>
void Vector<T>::push(T elem)
{

    if(dim_alocata < dim_total)
    {
        if(dim_alocata != 0)
        { data[dim_alocata] = elem; dim_alocata++; }
        else
        { data[0] = elem; dim_alocata++; }
    }
    else
    {
       /* int new_dim = dim_total*2;
        T* new_data = new T[dim_total];

        for(int i = 0; i < dim_total; i++)
            new_data[i] = data[i];

        delete[] data;

        data = new T[new_dim];

        for(int i = 0; i < dim_alocata; i++)
            new_data[i] = data[i];

        new_data[dim_alocata] = elem;
        dim_alocata++;

        dim_total = new_dim;
        //delete[] data;

        delete new_data;*/

        int new_dim = dim_total*2;
        T* new_data = new T[new_dim];

        for(int i = 0; i < dim_alocata; i++)
            new_data[i] = data[i];

        new_data[dim_alocata] = elem;
        dim_alocata++;
        dim_total = new_dim;

        data = new_data;
    }
}

template <typename T>
bool Vector<T>::find(T elem)
{
    bool gasit = false;
    for(int i = 0; i < dim_alocata; i++)
        if (elem == data[i])
        {
            if(gasit == false)
            {
                std::cout << std::endl;
                std::cout << "elem se afla pe poz: ";
            }
            std::cout << i << " ";
            gasit = true;
        }
    return gasit;
}

template <typename T>
void Vector<T>::sort()
{
    // heeeeeeei
}
template <>
void Vector<int>::sort()
{
    int aux = 0;
    for(int i = 0; i < dim_alocata-1; i++)
    for(int j = i+1 ; j < dim_alocata; j++)
        if( data[i] > data[j] )
            {
                aux = data[i];
                data[i] = data[j];
                data[j] = aux;
            }
}
/*
template<typename T>
void Vector<T>::operator=(const Vector<T>& param)
{
    for(int i = 0; i <= dim_alocata; i++)
        data[i] = param.data[i];

}
*/
/*
template<typename T>
Vector<T> Vector<T>::operator+(const Vector<T>& param)
{
    int result_dim;
    if ( dim_alocata < param.dim_alocata ) result_dim = dim_alocata;
    else result_dim = param.dim_alocata;

    Vector<T> result(0);
    for(int i = 0; i < result_dim; i++)
        result.data[i] = data[i] + param.data[i];

    return result;
}
*/

template<typename T>
Vector<T>::~Vector()
{
	delete[] data;
}

template<typename T>
int Vector<T>::size()
{
    return dim_alocata;
}

template<typename T>
void Vector<T>::info()
{
    std::cout << " size: " << size();
    std::cout << "; dim_totala: " << dim_total;
    std::cout << "; dim_alocata: " << dim_alocata;
    std::cout << std::endl;
}

template<typename T>
void Vector<T>::erase(int pos)
{
    if(pos < dim_alocata)
    {
        //if(pos == dim_alocata-1)
           // dim_alocata--;
        for(int i = pos; i < dim_alocata; i++)
            data[i] = data[i+1];
        dim_alocata--;
    }

}

Vector<int> A;

int n;

void citire(void)
{
    FILE *f = fopen("algsort.in","r");
    int x;
     
    fscanf(f,"%d",&n);
    for(int i=0;i<n;i++) {
        fscanf(f,"%d ",&x);
        A.push (x);
    }
         
    fclose(f);
}
 
void afisare(void)
{
    FILE *f = fopen("algsort.out","w");
     
    for(int i=0;i<n;i++)
        fprintf(f,"%d ",A[i]);
     
    fclose(f);
}
 
int main()
{
    citire();
    A.sort ();
    afisare();
    return 0;
}