import std.stdio, std.algorithm, std.conv, std.array, std.string, std.math, std.typecons, std.numeric;

void main()
{
    auto nk = readln.split.to!(long[]);
    auto N = nk[0];
    auto K = nk[1];
    long[] ps, ms;
    long zc;
    foreach (a; readln.split.to!(long[])) {
        if (a < 0) {
            ms ~= -a;
        } else if (a > 0) {
            ps ~= a;
        } else {
            ++zc;
        }
    }
    sort!"a < b"(ps);
    sort!"a < b"(ms);
    long l = long.max, r = long.min;

    if (!ps.empty && !ms.empty) l = ps[$-1] * -ms[$-1];
    if (ps.length > 1) l = min(l, ps[0] * ps[1]);
    if (ms.length > 1) l = min(l, ms[0] * ms[1]);

    if (!ps.empty && !ms.empty) r = ps[0] * -ms[0];
    if (ps.length > 1) r = max(r, ps[$-1] * ps[$-2]);
    if (ms.length > 1) r = max(r, ms[$-1] * ms[$-2]);

    if (K == 1) {
        writeln(l);
        return;
    }

    while (l+1 < r) {
        auto m = (l+r)/2;
        long k;
        if (m < 0) {
            foreach (p; ps) {
                size_t ll = 0, rr = ms.length;
                if (p * -ms[0] > m) continue;
                while (ll+1 < rr) {
                    auto mm = (ll+rr)/2;
                    if (p * -ms[mm] <= m) {
                        ll = mm;
                    } else {
                        rr = mm;
                    }
                }
                k += rr.to!long;
            }
        } else {
            k = (ps.length * ms.length).to!long + zc * (N-zc) + zc * (zc-1) / 2;
            if (m == 0) continue;
            foreach (i, p; ps[0..$-1]) {
                size_t ll = i+1, rr = ps.length;
                if (p * ps[i+1] > m) continue;
                while (ll+1 < rr) {
                    auto mm = (ll+rr)/2;
                    if (p * ps[mm] <= m) {
                        ll = mm;
                    } else {
                        rr = mm;
                    }
                }
                k += (ll-i).to!long;
            }
            foreach (i, p; ms[0..$-1]) {
                size_t ll = i+1, rr = ms.length;
                if (p * ms[i+1] > m) continue;
                while (ll+1 < rr) {
                    auto mm = (ll+rr)/2;
                    if (p * ms[mm] <= m) {
                        ll = mm;
                    } else {
                        rr = mm;
                    }
                }
                k += (ll-i).to!long;
            }
        }
        if (k < K) {
            l = m;
        } else {
            r = m;
        }
    }
    writeln(r);
}