#include <iostream>
using namespace std;

class prQueue
{
	private:
		int *a;
		int size;
		int m_maxSize;

		void siftup(int pos);
		void siftdown(int pos);
		void swap(int pos_a, int pos_b);
	public:
		prQueue(int maxSize);
		~prQueue();
		int isEmpty();
		int isFull();

		void insert(int n);
		void removeMin();
		int min();
};

void prQueue::siftup(int pos)
{
	int par_pos = (pos-1)/2;

	if ( pos > 0 && a[pos] < a[par_pos] )
	{
		swap( pos, par_pos );
		siftup( par_pos );
	}
}

void prQueue::siftdown(int pos)
{
	int l_child = 2*pos+1;
	int r_child = 2*pos+2;
	
	if ( l_child < size && r_child < size )
	{
		int min_child = ( a[l_child] < a[r_child] ) ? l_child : r_child;

		if ( a[pos] > a[min_child] )
		{
			swap(pos, min_child);
			siftdown(min_child);
		}
	}
	else if ( l_child < size && a[pos] > a[l_child] )
	{
		swap(pos, l_child);
		siftdown(l_child);
	}
}

void prQueue::swap(int pos_a, int pos_b)
{
	int tmp = a[pos_a];
	a[pos_a] = a[pos_b];
	a[pos_b] = tmp;
}

prQueue::prQueue(int maxSize)
{
	m_maxSize = maxSize;
	size = 0;
	a = new int[maxSize];
}

prQueue::~prQueue()
{
    delete [] a;
}

void prQueue::insert(int n)
{
	if ( size < m_maxSize )
	{
		a[size++] = n;
		siftup(size-1);
	}
}

void prQueue::removeMin()
{
	if ( size > 0 )
	{
		swap(0, --size);
		siftdown(0);
	}
}

int prQueue::min()
{
	return a[0];
}

int prQueue::isEmpty()
{
    if (size > 0)
        return 0;
    
    return 1;
}

int prQueue::isFull()
{
    if (size < m_maxSize)
        return 0;
    
    return 1;
}

int main()
{
	int n, k, t;

	freopen("sdo.in", "r", stdin);
	freopen("sdo.out", "w", stdout);
	
	prQueue my_queue(3000000);

	cin >> n;
	cin >> k;
	
	for (int i=0; i<n; i++)
	{
		cin >> t;
		my_queue.insert(t);
	}
	
	for (int i=0; i<k; i++)
	{
		cout << my_queue.min();
		my_queue.removeMin();
	}
}