#include <iostream>
#include <fstream>
#include <algorithm>

using namespace std;
ifstream in("sdo.in");
ofstream out("sdo.out");

#define ll long long
#define pb push_back
const int NMax = 3e6 + 5;

int N,K,nrHeap;
int heap[NMax];
// heap care retine valoarea maxima

void sift(int);
void percolate(int);
// sift muta un nod in jos in heap pana in pozitia corespunzatoare
// percolate muta un nod in sus in heap pana in pozitia corespunzatoare

int main() {
    in>>N>>K;
    for (int i=1;i <= N;++i) {
        int val;
        in>>val;

        if (nrHeap <= K) {
            // daca am citit doar un nr de elemente <= K,
            // atunci doar le introducem in heap
            heap[++nrHeap] = val;
            percolate(nrHeap);
        }
        else {
            // avem K+1 elemente in heap.
            // Se elimina heap[1], adica valoarea maxima,
            // din moment ce exista K numere mai mici ca aceasta
            // si se introduce noua valoare
            heap[1] = val;
            sift(1);
        }
    }

    // heap-ul are K+1 valori
    // se scoate maximul
    swap(heap[1],heap[nrHeap]);
    --nrHeap;

    sift(1);

    // iar cele K valori ramase sunt cele mai mici K valori din v
    // maximul dintre ele este a K-a statistica de ordine
    out<<heap[1]<<' ';

    in.close();out.close();
    return 0;
}

void sift(int node) {

    int son = 0;
    do {
        son = 0;
        int fs = node*2,
            ss = node*2 + 1;
        if (fs <= nrHeap) {
            son = fs;
            if (ss <= nrHeap && heap[ss] > heap[son]) {
                son = ss;
            }
        }

        if (son && heap[son] > heap[node]) {
            swap(heap[node],heap[son]);
            node = son;
        }
        else {
            son = 0;
        }
    }
    while (son);
}

void percolate(int node) {

    int dad = node/2;
    while (node != 1 && heap[node] > heap[dad]) {
        swap(heap[node],heap[dad]);
        node = dad;

        dad = node/2;
    }
}