#include <iostream>
#include <fstream>
#include <algorithm>
#include <queue>
#include <time.h>
#define MAXN 3000001

using namespace std;

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

int N, K, v[MAXN];
struct number_in_heap {
	int position, value;

	number_in_heap(int pos, int val) {
		position = pos;
		value = val;
	}
	inline bool operator < (const number_in_heap &x) const {
		return value > x.value;
	}
};

bool cmp(int a, int b) {
	return a > b;
}
void read() {
	f >> N >> K;
	for (int i = 1; i <= N; ++i) {
		f >> v[i];
	}
}
// O(n + klogk) - heap solution
int solve_heap_bfs() {
	priority_queue <number_in_heap> Q;
	make_heap(v + 1, v + N + 1, cmp);

	Q.push(number_in_heap(1, v[1]));
	for (int i = 1; i < K; ++i) {
		number_in_heap aux = Q.top();
		Q.pop();
		if (2 * aux.position <= N) {
			number_in_heap tmp = number_in_heap(2 * aux.position, v[2 * aux.position]);

			Q.push(tmp);
		}
		if (2 * aux.position + 1 <= N) {
			number_in_heap tmp = number_in_heap(2 * aux.position + 1, v[2 * aux.position + 1]);

			Q.push(tmp);
		}
	}
	return Q.top().value;
}

// O(n) - QuickSort pivot solution

int partition(int left, int right) {
	int random = left + rand() % (right - left);
	swap(v[random], v[right]);

	int pivot = v[right];
	int i = left - 1;
	for (int j = left; j <= right - 1; ++j) {
		if (v[j] < pivot) {
			++i;
			swap(v[i], v[j]);
		}
	}
	swap(v[i + 1], v[right]);
	return i + 1;
}
int solve_pivot(int left, int right) {
	if (left <= right) {
		int piv = partition(left, right);
		if (piv == K) {
			return v[piv];
		}
		if (K < piv) {
			return solve_pivot(left, piv - 1);
		} else {
			return solve_pivot(piv + 1, right);
		}
	}
	return -1;
} 
int main() {
	srand(time(NULL));
	read();
	// g << solve_heap_bfs();
	g << solve_pivot(1, N);
	return 0;
}