// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;



#define int long long

int lb=-2e18,ub=2e18;



signed main() {

    int n,k,a[200000];

    cin>>n>>k;

    for(int i=0;i<n;i++) cin>>a[i];

    sort(a,a+n);



    while(ub-lb>1){

        int mid=(ub+lb)/2,cnt=0;

        for(int i=0;i<n;i++){

            if(a[i]<0)

            	cnt+=min(n-(lower_bound(a,a+n,(long double)mid/a[i])-a),n-i);

            else if(a[i]>0)

            	cnt+=upper_bound(a+i,a+n,(long double)mid/a[i])-(a+i);

            else if(mid>=0)

            	cnt+=n-i;

			if(a[i]*a[i]<=mid) cnt--;

        }

        (cnt>=k?ub:lb)=mid;

    }

    cout<<ub<<endl;

	return 0;

}

// Optimized solution to the same problem (faster):
#include<iostream>

#include<cstdio>

#include<algorithm>

#include<cstring>

#include<queue>

#include<time.h>

#include<string>

#include<stack>

#include<cmath>

#include<map>

#include<set>

#define int long long

//#define double long double

using namespace std;

#define PI  3.1415926535898 

#define eqs 1e-6

const long long max_ = 2e5 + 7;

const int mod = 1e9 + 7;

const int inf = 1e9;

const long long INF = 1e18;

int read() {

	int s = 0, f = 1;

	char ch = getchar();

	while (ch<'0' || ch>'9') {

		if (ch == '-')

			f = -1;

		ch = getchar();

	}

	while (ch >= '0'&&ch <= '9') {

		s = s * 10 + ch - '0';

		ch = getchar();

	}

	return s * f;

}

int min(int a, int b) {

	return a < b ? a : b;

}

int max(int a, int b) {

	return a > b ? a : b;

}

int n, k, zhen[max_], fu[max_], zn, fn, zeronum = 0;;

bool solzhen(int stander) {

	int num = zeronum * (zn + fn);

	if (zeronum >= 2)num += (((zeronum - 2) * (zeronum - 1)) / 2) + (zeronum - 1);

	for (int i = 2; i <= zn; i++) {

		if (zhen[i] > stander)break;

		if (zhen[i] * zhen[i] <= stander) {

			num += i - 1; continue;

		}

		int wei = upper_bound(zhen + 1, zhen + 1 + i - 1, stander / zhen[i]) - zhen;

		if (wei == i || zhen[wei] * zhen[i] > stander)wei--;

		num += wei;

	}

	//正正算完了



	num += fn * zn;//负正算完了



	for (int i = 1; i < fn; i++) {

		if (-fu[i] > stander)continue;

		if (fu[i] * fu[i] <= stander) {

			num += (fn - i); continue;

		}

		int wei = lower_bound(fu + i + 1, fu + 1 + fn, stander / fu[i]) - fu;

		/*int t =stander / fu[i];

		if(t * fu[i] )

		int wei = lower_bound(fu + i, fu + 1 + fn, t) - fu;*/

		num += (fn - wei + 1);

	}

	//负负

	if (num >= k)return true;

	return false;

}

bool solfu(int stander) {

	int num = 0;//只需要算负数与正数的

	for (int i = 1; i <= fn; i++) {

		if (fu[i] <= stander) {

			num += zn; continue;

		}

		int wei = lower_bound(zhen + 1, zhen + 1 + zn,stander / fu[i]) - zhen;

		while (wei <= zn && zhen[wei] * fu[i] > stander) wei++;

		num += (zn - wei + 1);

	}

	if (num >= k)return true;

	return false;

}

bool judge(int stander) {

	if (stander >= 0) {

		return solzhen(stander);

	}

	else {

		return solfu(stander);

	}

}

int erfen(int L, int R) {

	if (L == R)return L;

	if (L > R)return L - 1;

	int mid = L + (R - L) / 2;

	if (judge(mid)) {

		//能够满足大于等于第k大

		return erfen(L, mid);

	}

	else {

		return erfen(mid + 1, R);

	}

}

signed main() {

	n = read(), k = read();



	for (int i = 1; i <= n; i++) {

		int t = read();

		if (t == 0) {

			zeronum++;

		}

		else

			if (t > 0) {

				zhen[++zn] = t;

			}

			else {

				fu[++fn] = t;

			}

	}

	sort(zhen + 1, zhen + 1 + zn);

	sort(fu + 1, fu + 1 + fn);

	//cout << erfen(4, 5);

	printf("%lld", erfen(-INF, INF));

	return 0;

}

// Fastest known solution for this problem: