#include <fstream>
using namespace std;

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

template <typename T>
struct nodDS {
	T value;
	struct nodDS<T> *next = NULL, *prev = NULL;
};

template <typename T>
struct nodH {
	T value;
	nodH<T> *left = NULL, *right = NULL, *father = NULL;
};

template <typename T>
void SwapT(T &x, T &y) {
	T aux = x; x = y; y = aux;
}

template <typename T>
struct Deque {
	nodDS<T> *front = NULL, *back = NULL;
	void (*pNodePrint)(ostream& ,T) = NULL;

	void PushBack(T x) {
		nodDS<T> *p = new nodDS<T>;
		p->value = x;
		p->prev = back;
		if(!front) front = p;
		else back->next = p;
		back = p;
	}

	void PushFront(T x) {
		nodDS<T> *p = new nodDS<T>;
		p->value = x;
		p->next = front;
		if(!back) back = p;
		else front->prev = p;
		front = p;
	}

	T PopBack() {
		T temp = back->value;
		nodDS<T> *q = back;
		if(back->prev) {
			back = back->prev;
			back->next = NULL;
		} else front = back = NULL;
		delete q;
		return temp;
	}

	T PopFront() {
		T temp = front->value;
		nodDS<T> *q = front;
		if(front->next) {
			front = front->next;
			front->prev = NULL;
		} else front = back = NULL;
		delete q;
		return temp;
	}

	T PeekFront() {
		return front->value;
	}

	T PeekBack() {
		return back->value;
	}

	bool IsEmpty() {
		return front == NULL;
	}
};

enum HeapType {MinHeap = -1, MaxHeap = 1, MinMaxHeap};

int Compare(int x, int y) {
	if(x == y) return 0;
	if(x < y) return -1;
	return 1;
}

template <typename T>
struct Heap {
private:
	Deque<nodH<T>*> latestNodes;
public:
	struct nodH<T> *root = NULL;
	HeapType heapType;
	int (*comp)(T, T);

	Heap(HeapType type = MinHeap, int (*cp)(T, T) = NULL) { /// constructor customizabil cu functie comparator
		heapType = type;
		if(!cp)comp = Compare;
	}

	void Insert(T x) {
		if(!root) {
			root = new nodH<T>;
			root->value = x;
			latestNodes.PushBack(root);
		} else {
			nodH<T> *p, *q;
			p = latestNodes.PeekFront();
			q = new nodH<T>;
			q->value = x;
			q->father = p;
			if(!p->left) p->left = q;
			else if(!p->right) {
				p->right = q;
				latestNodes.PopFront();
			}

			PushUp(q);

			latestNodes.PushBack(q);
		}
	}

	T CutHeadOff() {
		T tempVal = root->value;
		if(root->left == root->right && root->left == NULL) {
			delete root;
			root = NULL;
			latestNodes.PopBack();
		} else {
			nodH<T> *p, *q = latestNodes.PopBack();
			SwapT(root->value, q->value);

			p = q->father;
			if(p->left == q)
				p->left = NULL;
			else {
				p->right = NULL;
				latestNodes.PushFront(p);
			}
			delete q;

			PushDown(root);
		}
		return tempVal;
	}

	void PushUp(nodH<T> *p) {
		while(p->father && comp(p->value, p->father->value) == heapType) {
			SwapT(p->value, p->father->value);
			p = p->father;
		}
	}

	void PushDown(nodH<T> *p) {
		nodH<T> *q;
		bool rL;
		while(p->left || p->right) {
			if(comp(p->value, p->left->value) != -heapType &&
			        ((p->right && comp(p->value, p->right->value) != -heapType) || !p->right))  break;

			rL = true;
			if(p->right && comp(p->left->value, p->right->value) == -heapType) rL = false;

			if(rL) q = p->left;
			else q = p->right;

			SwapT(p->value, q->value);
			p = q;
		}
	}

	bool IsEmpty() {
		return root == NULL;
	}
};


int main(){
    Heap<int> hp(MinHeap);
    int x;
    f>>x;
    while(f>>x) hp.Insert(x);

    while(!hp.IsEmpty())
        g<<hp.CutHeadOff()<<' ';

    g<<'\n';
    f.close();
    g.close();
    return 0;
}