#include <bits/stdc++.h>
using namespace std;

#define MAX_N 200000
long Aplus[MAX_N], Aminus[MAX_N], Plus = 0, Minus = 0, zero = 0, N, K;

long howmanyplus(long k){
    long cnt = 0;
    long i = 0, j = Plus - 1;
    while(Aplus[i] * Aplus[j] > k && j >= 0) j--;
    while(j >= 0) {
        while(Aplus[i + 1] * Aplus[j] <= k && i + 1 < Plus) i++;
        cnt += i + 1;
        if (i >= j) cnt--;
        j--;
    }
    i = 0; j = Minus - 1;
    while(Aminus[i] * Aminus[j] > k && j >= 0) j--;
    while(j >= 0) {
        while(Aminus[i + 1] * Aminus[j] <= k && i + 1 < Minus) i++;
        cnt += i + 1;
        if (i >= j) cnt--;
        j--;
    }
    return cnt / 2;
}
 /*   while(i < Plus - 1){
        long j = i + 1;
        if (Aplus[i] * Aplus[j] > k) break;
        while(Aplus[i] * Aplus[j] <= k && j < Plus) {
            j++;
            cnt++;
        }
        i++;
    }
    i = 0;
    while(i < Minus - 1){
        long j = i + 1;
        if (Aminus[i] * Aminus[j] > k) break;
        while(Aminus[i] * Aminus[j] <= k && j < Minus) j++;
        cnt += j - i - 1;
        i++;
    }
    return cnt;
}*/

long howmanyminus(long k){
    long cnt = 0;
    long i = 0, j = Minus - 1;
    while(Aplus[i] * Aminus[j] >= k && j >= 0) j--;
    while(j >= 0){
        while(Aplus[i + 1] * Aminus[j] < k && i + 1 < Plus) i++;
        cnt += i + 1;
        j--;
    }
    return Plus * Minus - cnt;
}

int main(){
    cin >> N >> K;
    for (long i = 0; i < N; i++){
        long a; cin >> a;
        if (a == 0) {
            zero++;
            continue;
        }
        if (a > 0) {
            Aplus[Plus] = a;
            Plus++;
            continue;
        }
        if (a < 0) {
            Aminus[Minus] = -1 * a;
            Minus++;
            continue;
        }
    }
    sort(Aplus, Aplus + Plus);
    sort(Aminus, Aminus + Minus);
    if (K <= Plus * Minus) {
        long right = Aminus[Minus - 1] * Aplus[Plus - 1] + 1;
        long left = 1;
        while(left < right){
            long mid = (left + right) / 2;
            if (howmanyminus(mid) >= K && howmanyminus(mid + 1) < K){
                cout << -1 * mid << endl;
                return 0;
            }
            if (howmanyminus(mid) < K){
                right = mid;
            } else {
                left = mid + 1;
            }
        }
    }
    if (K <= Plus * Minus + zero * (zero - 1) / 2 + zero * (Plus + Minus) && K > Plus * Minus){
        cout << 0 << endl;
        return 0;
    }
        K = K - (Plus * Minus + zero * (zero - 1) / 2 + zero * (Plus + Minus));
        long right;
        if (Minus <= 1) right = Aplus[Plus - 1] * Aplus[Plus - 2] + 1;
        else{ if (Plus <= 1) right = Aminus[Minus - 1] * Aminus[Minus - 2] + 1;
        else right = max(Aminus[Minus - 1] * Aminus[Minus - 2], Aplus[Plus - 1] * Aplus[Plus - 2]) + 1;
        }
        long left = 1;
        while(left < right){
            long mid = (left + right) / 2;
            if (howmanyplus(mid) >= K && howmanyplus(mid - 1) < K){
                cout << mid << endl;
                return 0;
            }
            if (howmanyplus(mid) >= K) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        return 0;
}

Measured memory_bytes: 1664