#include <algorithm>
#include <cassert>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>

#include <limits.h>

using namespace std;

typedef long long ll;

template<class T>
inline bool chmax(T &a, T b) {
    if(a < b) {
        a = b;
        return true;
    }
    return false;
}

template<class T>
inline bool chmin(T &a, T b) {
    if(a > b) {
        a = b;
        return true;
    }
    return false;
}

const ll MAX_A = ll(1e9);

vector<ll> as;

// plus values
vector<ll> ps;

// minus values
vector<ll> ms;

ll plus_cnt, zero_cnt, minus_cnt;
ll plus_pairs, zero_pairs, minus_pairs;

ll solve_minus(const int N, const ll K) {
    // A pair consists of a plus value and a minus value

    sort(ps.begin(), ps.end());
    sort(ms.begin(), ms.end());

    auto check = [&](const ll v) {
        ll cnt = 0;
        for (auto p : ps) {
            int left = -1, right = (int) ms.size(), mid;
            while (right - left > 1) {
                mid = left + (right - left) / 2;
                if (ms[mid] * p <= v) {
                    left = mid;
                } else {
                    right = mid;
                }
            }
            cnt += right;
            // printf("p: %lld, cnt += %d\n", p, right);
        }
        // printf("v: %lld, cnt: %lld\n", v, cnt);
        return cnt >= K;
    };

    ll left = -LONG_LONG_MAX, right = 0, mid;
    while (right - left > 1) {
        mid = left + (right - left) / 2;
        // printf("left: %lld, right: %lld, mid: %lld\n", left, right, mid);
        if (check(mid)) {
            right = mid;
        } else {
            left = mid;
        }
    }

    return right;
}

ll solve_plus(const int N, const ll K) {
    // A pair consists of (plus, plus) or (minus, minus)

    sort(ps.begin(), ps.end());
    sort(ms.rbegin(), ms.rend());

    auto check = [&](const ll v) {
        ll cnt = 0;
        for (int i = 0; i < (int) ps.size(); i++) {
            int left = i, right = (int) ps.size(), mid;
            while (right - left > 1) {
                mid = left + (right - left) / 2;
                if (ps[i] * ps[mid] <= v) {
                    left = mid;
                } else {
                    right = mid;
                }
            }
            cnt += left - i;
        }

        for (int i = 0; i < (int) ms.size(); i++) {
            int left = i, right = (int) ms.size(), mid;
            while (right - left > 1) {
                mid = left + (right - left) / 2;
                if (ms[i] * ms[mid] <= v) {
                    left = mid;
                } else {
                    right = mid;
                }
            }
            cnt += left - i;
        }

        // printf("v: %lld, cnt: %lld\n", v, cnt);
        return cnt >= K;
    };

    ll left = 0, right = LONG_LONG_MAX, mid;
    while (right - left > 1) {
        mid = left + (right - left) / 2;
        // printf("left: %lld, right: %lld, mid: %lld\n", left, right, mid);

        if (check(mid)) {
            right = mid;
        } else {
            left = mid;
        }
    }

    return right;
}

int main(void) {
    ll N;
    ll K;
    cin >> N >> K;

    as.resize(N);
    for (int i = 0; i < N; i++) {
        cin >> as[i];
        if (as[i] > 0) {
            plus_cnt++;
            ps.push_back(as[i]);
        } else if (as[i] < 0) {
            minus_cnt++;
            ms.push_back(as[i]);
        } else {
            zero_cnt++;
        }
    }

    minus_pairs = plus_cnt * minus_cnt;
    plus_pairs = (plus_cnt * (plus_cnt - 1)) / 2 + (minus_cnt * (minus_cnt - 1) / 2);
    zero_pairs = (N * (N - 1) / 2) - minus_pairs - plus_pairs;
    // printf("minus_pairs: %lld, zero_pairs: %lld, plus_pairs: %lld\n",
    //         minus_pairs, zero_pairs, plus_pairs);

    if (K <= minus_pairs) {
        cout << solve_minus(N, K) << endl;
    } else if (K <= minus_pairs + zero_pairs) {
        cout << 0 << endl;
    } else {
        cout << solve_plus(N, K - minus_pairs - zero_pairs) << endl;
    }

    return 0;
}


Measured memory_bytes: 6660