#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 INF = LONG_LONG_MAX / 2;
const ll MAX_A = ll(1e9);

vector<ll> as;
vector<ll> ps; // positive numbers
vector<ll> ms; // negative numbers

bool check1(const ll v, const ll N, const ll K) {
    ll cnt = 0;

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

ll solve1(const ll N, const ll K) {
    ll left = -INF, right = 0, mid;
    while (right - left > 1) {
        mid = left + (right - left) / 2;
        // printf("left: %lld, right: %lld, mid: %lld\n", left, right, mid);
        if (check1(mid, N, K)) {
            left = mid;
        } else {
            right = mid;
        }
    }
    return left;
}

bool check2(const ll v, const ll N, const ll K) {
    ll cnt = 0;

    auto f = [](const ll v, const vector<ll> &xs) {
        ll cnt = 0;
        for (int i = 0; i < (int) xs.size(); i++) {
            ll x = xs[i];
            int left = -1, right = (int) xs.size(), mid;
            while (right - left > 1) {
                mid = left + (right - left) / 2;
                // printf("  left: %d, right: %d, mid: %d\n", left, right, mid);
                ll y = xs[mid];
                if (x * y < v) {
                    left = mid;
                } else {
                    right = mid;
                }
            }
            if (x * x < v) cnt--;
            // printf("  cnt += %lld\n", (ll) right - (i + 1));
            cnt += right;
        }
        return cnt / 2;
    };

    cnt += f(v, ps);

    vector<ll> ms_abs = ms;
    for (int i = 0; i < (int) ms_abs.size(); i++) {
        ms_abs[i] = -1 * ms_abs[i];
    }
    reverse(ms_abs.begin(), ms_abs.end());
    cnt += f(v, ms_abs);

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

ll solve2(const ll N, const ll K) {
    ll left = 0, right = INF, mid;
    while (right - left > 1) {
        mid = left + (right - left) / 2;
        if (check2(mid, N, K)) {
            left = mid;
        } else {
            right = mid;
        }
    }
    return left;
}

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

    ll p_count = 0; // count for positive numbers
    ll m_count = 0; // count for negative numbers
    ll z_count = 0; // count for zero
    as.resize(N);
    for (int i = 0; i < N; i++) {
        cin >> as[i];
        if (as[i] > 0) {
            p_count++;
            ps.push_back(as[i]);
        } else if (as[i] < 0) {
            m_count++;
            ms.push_back(as[i]);
        } else {
            z_count++;
        }
    }

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

    bool ok = false;
    ll ans;

    const ll num_of_negative = p_count * m_count;
    if (!ok && K <= num_of_negative) {
        ok = true;
        ans = solve1(N, K);
    }
    K -= num_of_negative;

    const ll num_of_zero = z_count * (p_count + m_count) + (z_count * (z_count - 1) / 2);
    if (!ok && K <= num_of_zero) {
        ok = true;
        ans = 0;
    }
    K -= num_of_zero;

    if (!ok) {
        ok = true;
        ans = solve2(N, K);
    }

    cout << ans << endl;

    return 0;
}


Measured memory_bytes: 4592