#include <bits/stdc++.h>
using namespace std;
#define int long long
constexpr long long INF = 1000000000000000000LL + 8;
// 初項0公差1の等差級数
constexpr int arithSeries(int n) { return n * (n - 1) / 2; }

int countMinusPairLessThanX(const vector<int> &minus_a, const vector<int> &plus_a, int x)
{
    // xが0以上ならばすべてのペア
    if (x >= 0)
        return minus_a.size() * plus_a.size();

    auto isOk = [x](int s, int t) { return s * t < x; };

    int count = 0;

    // minus_a[i]とペアを組んだとき、X未満になるペアを数えたい
    // minus_a[i]とペアを組んだとき、X未満になるplus_a[j]のうち最も小さいjを二分探索する
    for (int i = 0; i < minus_a.size(); i++)
    {
        // めぐる式二分探索
        // (ng, ok] を探索
        int ok = plus_a.size(); // X未満になる値へのインデックス
        int ng = -1;            // X以上になる値へのインデックス
        while (abs(ok - ng) > 1)
        {
            int mid = (ok + ng) / 2;
            if (isOk(minus_a[i], plus_a[mid]))
                ok = mid;
            else
                ng = mid;
        }

        // (plus_aの個数) - ok がX未満になるペアの個数
        count += plus_a.size() - ok;
    }

    return count;
}

int searchMinusPairGreaterOrEqualX(const vector<int> &minus_a, const vector<int> &plus_a, int x)
{
    // xが0以上ならば例外
    if (x >= 0)
        return 0;

    auto isOk = [x](int s, int t) { return s * t >= x; };

    int min_pair = INF;

    // minus_a[i]とペアを組んだとき、X以上になるplus_a[j]のうち最も小さいplus_a[j]を二分探索する
    for (int i = 0; i < minus_a.size(); i++)
    {
        // めぐる式二分探索
        // [ok, ng) を探索
        int ok = -1;            // X以上になる値へのインデックス
        int ng = plus_a.size(); // X未満になる値へのインデックス
        while (abs(ok - ng) > 1)
        {
            int mid = (ok + ng) / 2;
            if (isOk(minus_a[i], plus_a[mid]))
                ok = mid;
            else
                ng = mid;
        }

        // X以上になるplus_a[j] が無い → ペア最小値更新はしない
        if (ok == -1)
            continue;

        min_pair = min(minus_a[i] * plus_a[ok], min_pair);
    }

    return min_pair;
}

int countPlusPairLessThanX(const vector<int> &minus_a, const vector<int> &plus_a, int x)
{
    // x が0以下ならば0
    if (x <= 0)
        return 0;

    auto isOk = [x](int s, int t) { return s * t <= x; };

    int count = 0;

    // minus_a からペアを組む

    // minus_a[i]とペアを組んだとき、X以下になるペアを数えたい
    // minus_a[i]とペアを組んだとき、X以下になるminus_a[j]のうち最も大きいjを探索する
    for (int i = 0; i < minus_a.size(); i++)
    {
        // めぐる式二分探索
        // (ng, ok] を探索
        int ng = i; // 自分同士と過去に探索したペアは含まない
        int ok = minus_a.size();
        while (abs(ok - ng) > 1)
        {
            int mid = (ok + ng) / 2;
            if (isOk(minus_a[i], minus_a[mid]))
                ok = mid;
            else
                ng = mid;
        }

        count += minus_a.size() - ok;
    }

    // plus_a からペアを組む

    // plus_a[i]とペアを組んだとき、X以下になるペアを数えたい
    // plus_a[i]とペアを組んだとき、X以下になるplus_a[j]のうち最も大きいjを探索する
    for (int i = 0; i < plus_a.size(); i++)
    {
        // めぐる式二分探索
        // [ok, ng) を探索
        int ok = i;
        int ng = plus_a.size();
        while (abs(ok - ng) > 1)
        {
            int mid = (ok + ng) / 2;
            if (isOk(plus_a[i], plus_a[mid]))
                ok = mid;
            else
                ng = mid;
        }

        count += ok - i;
    }

    return count;
}

int searchPlusPairGreaterOrEqualX(const vector<int> &minus_a, const vector<int> &plus_a, int x)
{
    // x が0以下ならば例外
    if (x <= 0)
        return 0;

    auto isOk = [x](int s, int t) { return s * t >= x; };

    int min_pair = INF;

    // minus_a からペアを組む

    // minus_a[i]とペアを組んだとき、X以上になるminus_a[j]のうち最も小さいjを二分探索する
    for (int i = 0; i < minus_a.size(); i++)
    {
        // めぐる式二分探索
        // [ok, ng) を探索
        int ok = i;
        int ng = minus_a.size();
        while (abs(ok - ng) > 1)
        {
            int mid = (ok + ng) / 2;
            if (isOk(minus_a[i], minus_a[mid]))
                ok = mid;
            else
                ng = mid;
        }

        // X以上になるminus_a[j] が無い → ペア最小値更新はしない
        if (ok == i)
            continue;

        min_pair = min(minus_a[i] * minus_a[ok], min_pair);
    }

    // plus_a からペアを組む

    // plus_a[i]とペアを組んだとき、X以上になるplus_a[j]のうち最も小さいjを二分探索する
    for (int i = 0; i < plus_a.size(); i++)
    {
        // めぐる式二分探索
        // (ng, ok] を探索
        int ng = i;
        int ok = plus_a.size();
        while (abs(ok - ng) > 1)
        {
            int mid = (ok + ng) / 2;
            if (isOk(plus_a[i], plus_a[mid]))
                ok = mid;
            else
                ng = mid;
        }

        // X以上になるplus_a[j] が無い → ペア最小値更新はしない
        if (ok >= plus_a.size())
            continue;

        min_pair = min(plus_a[i] * plus_a[ok], min_pair);
    }

    return min_pair;
}

int naiveSolve(vector<int> &a, int k)
{
    priority_queue<int, vector<int>, greater<int>> pq;
    for (int i = 0; i < a.size(); i++)
        for (int j = i + 1; j < a.size(); j++)
            pq.push(a[i] * a[j]);

    for (int i = 0; i < k - 1; i++)
    {
        cerr << pq.top() << " ";
        pq.pop();
    }
    cerr << pq.top() << endl;
    return pq.top();
}

signed main()
{
    cin.tie(0);
    ios::sync_with_stdio(0);
    cout << fixed << setprecision(16);

    int n, k;
    cin >> n >> k;
    vector<int> a(n);
    for (auto &&x : a)
        cin >> x;

    sort(a.begin(), a.end());

    // 0、0より大きい数のインデックスを二分探索
    auto lb0 = lower_bound(a.begin(), a.end(), 0);
    auto ub0 = upper_bound(a.begin(), a.end(), 0);
    // 負、0、正の数の個数を数える
    int n_minus_a = lb0 - a.begin();
    int n_zero_a = ub0 - lb0;
    int n_plus_a = a.end() - ub0;

    // 負、0、正のペアの個数を数える
    int n_minus_pairs = n_minus_a * n_plus_a;
    int n_zeros_pairs = arithSeries(n_zero_a) + n_zero_a * (n_minus_a + n_plus_a);
    int n_plus_pairs = arithSeries(n_plus_a) + arithSeries(n_minus_a);

    vector<int> minus_a, plus_a;
    minus_a.assign(a.begin(), lb0);
    plus_a.assign(ub0, a.end());

    int ans;

#ifdef DEBUG
    cout << naiveSolve(a, k) << endl;
#endif

    // k番目の数が負
    if (k <= n_minus_pairs)
    {
        // x未満のペアがいくつあるか数える
        // countMinusPairLessThanX(minus_a, plus_a, x);

        // x未満のペアがk-1個になるxを求める
        auto isOk = [minus_a, plus_a, k](int x) { return countMinusPairLessThanX(minus_a, plus_a, x) >= k - 1; };

        int ok = 0;    // ペアがk-1個以上になるx
        int ng = -INF; // ペアがk-1個以下になるx
        while (abs(ok - ng) > 1)
        {
            int mid = (ok + ng) / 2;
            if (isOk(mid))
                ok = mid;
            else
                ng = mid;
        }
        const int x = ok;

        // x以上のうち最も小さいペアを探す
        ans = searchMinusPairGreaterOrEqualX(minus_a, plus_a, x);
    }
    // k番目の数が0
    else if (k <= n_minus_pairs + n_zeros_pairs)
    {
        ans = 0;
    }
    // k番目の数が正
    else
    {
        // kから負、0のペアの個数を引く 正のペアのk番目を求める
        const int k_offset = n_minus_pairs + n_zeros_pairs;
        k -= k_offset;

        // x以下のペアがいくつあるか数える
        // countPlusPairLessThanX(minus_a, plus_a, x);

        // x以下のペアがk個になるxを求める
        auto isOk = [minus_a, plus_a, k](int x) { return countPlusPairLessThanX(minus_a, plus_a, x) >= k; };

        int ok = INF; // ペアがk個以上になるx
        int ng = 0;   // ペアがk個未満になるx
        while (abs(ok - ng) > 1)
        {
            int mid = (ok + ng) / 2;
            if (isOk(mid))
                ok = mid;
            else
                ng = mid;
        }
        const int x = ok;

        // x以上のうち最も小さいペアを探す
        ans = searchPlusPairGreaterOrEqualX(minus_a, plus_a, x);
    }

    cout << ans << endl;
}


Measured memory_bytes: 4736