#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <deque>
#include <list>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>

using namespace std;

//typedef
typedef long long LL;
typedef vector<LL> VL;
typedef vector<VL> VVL;
typedef vector<string> VS;
typedef pair<LL, LL> PLL;

//conversion
inline LL toLong(string s) {LL v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}

//math
//-------------------------------------------
template<class T> inline T sqr(T x) {return x*x;}

//container util
//------------------------------------------
#define ALL(a)  (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) LL((a).size())
#define EACH(i,c) for(auto i=(c).begin(); i!=(c).end(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())

//repetition
#define FOR(i,a,b) for(LL i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)
#define UNTIL(p) while(!(p))

//constant
const double EPS = 1e-5;
const double PI  = acos(-1.0);

//debug
#define dump(x)  cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;

#define PUTS(x) cout << (x) << endl;

const LL INF = 2000000000000000000LL;

template<class Functor>
LL bin_search(LL initial_ng, LL initial_ok, Functor functor){
    LL ng = initial_ng;
    LL ok = initial_ok;

    while(abs(ok - ng) > 1){
        LL mid = (ok + ng) / 2;
        if(functor(mid)) ok = mid;
        else ng = mid;
    }
    return ok;
}

int main(void){
    cin.tie(0);
    ios::sync_with_stdio(false);
    LL n,k;
    cin>>n>>k;
    VL a(n);
    REP(i,n)cin>>a[i];
    SORT(a);

    VL neg;
    VL pos;
    LL zero_count = 0;
    REP(i,n){
        if(a[i] < 0)neg.PB(a[i]);
        if(a[i] > 0)pos.PB(a[i]);
        if(a[i] == 0)zero_count++;
    }
    LL neg_count = neg.size();
    LL pos_count = pos.size();

    LL mul_neg = neg_count * pos_count; 
    LL mul_zero = zero_count * (n-1) - zero_count * (zero_count - 1) / 2;
    if(k <= mul_neg){
        reverse(ALL(pos));
        LL ans = bin_search(0LL, -INF, [&](LL mid){
            LL cnt1 = 0;
            LL right = neg_count - 1;
            REP(i, pos_count){
                while(right >= 0 && pos[i] * neg[right] >= mid)right--;
                if(right < 0)break;
                cnt1 += right+1;
            }

            return cnt1 < k;
        });
        PUTS(ans);
    }
    else if(k <= mul_neg + mul_zero){
        PUTS(0);
    }
    else{
        k -= mul_neg;
        k -= mul_zero;
        reverse(ALL(neg));
        LL ans = bin_search(INF, 0LL, [&](LL mid){
            LL cnt1 = 0;
            LL right = pos_count - 1;
            REP(i, pos_count){
                while(right >= 0 && pos[i] * pos[right] >= mid)right--;
                if(right < 0)break;
                cnt1 += right+1;
                if(i <= right)cnt1--;
            }
            cnt1 /= 2;

            LL cnt2 = 0;
            right = neg_count - 1;
            REP(i, neg_count){
                while(right >= 0 && neg[i] * neg[right] >= mid)right--;
                if(right < 0)break;
                cnt2 += right+1;
                if(i <= right)cnt2--;
            }
            cnt2 /= 2;

            return cnt1 + cnt2 < k;
        });
        PUTS(ans);
    }
}

Measured memory_bytes: 4084